//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2022 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

import Foundation
import SotoCore

extension ConfigService {
    // MARK: Enums

    public enum AggregateConformancePackComplianceSummaryGroupKey: String, CustomStringConvertible, Codable, _SotoSendable {
        case accountId = "ACCOUNT_ID"
        case awsRegion = "AWS_REGION"
        public var description: String { return self.rawValue }
    }

    public enum AggregatedSourceStatusType: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "FAILED"
        case outdated = "OUTDATED"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum AggregatedSourceType: String, CustomStringConvertible, Codable, _SotoSendable {
        case account = "ACCOUNT"
        case organization = "ORGANIZATION"
        public var description: String { return self.rawValue }
    }

    public enum ChronologicalOrder: String, CustomStringConvertible, Codable, _SotoSendable {
        case forward = "Forward"
        case reverse = "Reverse"
        public var description: String { return self.rawValue }
    }

    public enum ComplianceType: String, CustomStringConvertible, Codable, _SotoSendable {
        case compliant = "COMPLIANT"
        case insufficientData = "INSUFFICIENT_DATA"
        case nonCompliant = "NON_COMPLIANT"
        case notApplicable = "NOT_APPLICABLE"
        public var description: String { return self.rawValue }
    }

    public enum ConfigRuleComplianceSummaryGroupKey: String, CustomStringConvertible, Codable, _SotoSendable {
        case accountId = "ACCOUNT_ID"
        case awsRegion = "AWS_REGION"
        public var description: String { return self.rawValue }
    }

    public enum ConfigRuleState: String, CustomStringConvertible, Codable, _SotoSendable {
        case active = "ACTIVE"
        case deleting = "DELETING"
        case deletingResults = "DELETING_RESULTS"
        case evaluating = "EVALUATING"
        public var description: String { return self.rawValue }
    }

    public enum ConfigurationItemStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case ok = "OK"
        case resourceDeleted = "ResourceDeleted"
        case resourceDeletedNotRecorded = "ResourceDeletedNotRecorded"
        case resourceDiscovered = "ResourceDiscovered"
        case resourceNotRecorded = "ResourceNotRecorded"
        public var description: String { return self.rawValue }
    }

    public enum ConformancePackComplianceType: String, CustomStringConvertible, Codable, _SotoSendable {
        case compliant = "COMPLIANT"
        case insufficientData = "INSUFFICIENT_DATA"
        case nonCompliant = "NON_COMPLIANT"
        public var description: String { return self.rawValue }
    }

    public enum ConformancePackState: String, CustomStringConvertible, Codable, _SotoSendable {
        case createComplete = "CREATE_COMPLETE"
        case createFailed = "CREATE_FAILED"
        case createInProgress = "CREATE_IN_PROGRESS"
        case deleteFailed = "DELETE_FAILED"
        case deleteInProgress = "DELETE_IN_PROGRESS"
        public var description: String { return self.rawValue }
    }

    public enum DeliveryStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case failure = "Failure"
        case notApplicable = "Not_Applicable"
        case success = "Success"
        public var description: String { return self.rawValue }
    }

    public enum EvaluationMode: String, CustomStringConvertible, Codable, _SotoSendable {
        case detective = "DETECTIVE"
        case proactive = "PROACTIVE"
        public var description: String { return self.rawValue }
    }

    public enum EventSource: String, CustomStringConvertible, Codable, _SotoSendable {
        case awsConfig = "aws.config"
        public var description: String { return self.rawValue }
    }

    public enum MaximumExecutionFrequency: String, CustomStringConvertible, Codable, _SotoSendable {
        case oneHour = "One_Hour"
        case sixHours = "Six_Hours"
        case threeHours = "Three_Hours"
        case twelveHours = "Twelve_Hours"
        case twentyFourHours = "TwentyFour_Hours"
        public var description: String { return self.rawValue }
    }

    public enum MemberAccountRuleStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case createFailed = "CREATE_FAILED"
        case createInProgress = "CREATE_IN_PROGRESS"
        case createSuccessful = "CREATE_SUCCESSFUL"
        case deleteFailed = "DELETE_FAILED"
        case deleteInProgress = "DELETE_IN_PROGRESS"
        case deleteSuccessful = "DELETE_SUCCESSFUL"
        case updateFailed = "UPDATE_FAILED"
        case updateInProgress = "UPDATE_IN_PROGRESS"
        case updateSuccessful = "UPDATE_SUCCESSFUL"
        public var description: String { return self.rawValue }
    }

    public enum MessageType: String, CustomStringConvertible, Codable, _SotoSendable {
        case configurationItemChangeNotification = "ConfigurationItemChangeNotification"
        case configurationSnapshotDeliveryCompleted = "ConfigurationSnapshotDeliveryCompleted"
        case oversizedConfigurationItemChangeNotification = "OversizedConfigurationItemChangeNotification"
        case scheduledNotification = "ScheduledNotification"
        public var description: String { return self.rawValue }
    }

    public enum OrganizationConfigRuleTriggerType: String, CustomStringConvertible, Codable, _SotoSendable {
        case configurationItemChangeNotification = "ConfigurationItemChangeNotification"
        case oversizedConfigurationItemChangeNotifcation = "OversizedConfigurationItemChangeNotification"
        case scheduledNotification = "ScheduledNotification"
        public var description: String { return self.rawValue }
    }

    public enum OrganizationConfigRuleTriggerTypeNoSN: String, CustomStringConvertible, Codable, _SotoSendable {
        case configurationItemChangeNotification = "ConfigurationItemChangeNotification"
        case oversizedConfigurationItemChangeNotifcation = "OversizedConfigurationItemChangeNotification"
        public var description: String { return self.rawValue }
    }

    public enum OrganizationResourceDetailedStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case createFailed = "CREATE_FAILED"
        case createInProgress = "CREATE_IN_PROGRESS"
        case createSuccessful = "CREATE_SUCCESSFUL"
        case deleteFailed = "DELETE_FAILED"
        case deleteInProgress = "DELETE_IN_PROGRESS"
        case deleteSuccessful = "DELETE_SUCCESSFUL"
        case updateFailed = "UPDATE_FAILED"
        case updateInProgress = "UPDATE_IN_PROGRESS"
        case updateSuccessful = "UPDATE_SUCCESSFUL"
        public var description: String { return self.rawValue }
    }

    public enum OrganizationResourceStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case createFailed = "CREATE_FAILED"
        case createInProgress = "CREATE_IN_PROGRESS"
        case createSuccessful = "CREATE_SUCCESSFUL"
        case deleteFailed = "DELETE_FAILED"
        case deleteInProgress = "DELETE_IN_PROGRESS"
        case deleteSuccessful = "DELETE_SUCCESSFUL"
        case updateFailed = "UPDATE_FAILED"
        case updateInProgress = "UPDATE_IN_PROGRESS"
        case updateSuccessful = "UPDATE_SUCCESSFUL"
        public var description: String { return self.rawValue }
    }

    public enum OrganizationRuleStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case createFailed = "CREATE_FAILED"
        case createInProgress = "CREATE_IN_PROGRESS"
        case createSuccessful = "CREATE_SUCCESSFUL"
        case deleteFailed = "DELETE_FAILED"
        case deleteInProgress = "DELETE_IN_PROGRESS"
        case deleteSuccessful = "DELETE_SUCCESSFUL"
        case updateFailed = "UPDATE_FAILED"
        case updateInProgress = "UPDATE_IN_PROGRESS"
        case updateSuccessful = "UPDATE_SUCCESSFUL"
        public var description: String { return self.rawValue }
    }

    public enum Owner: String, CustomStringConvertible, Codable, _SotoSendable {
        case aws = "AWS"
        case customLambda = "CUSTOM_LAMBDA"
        case customPolicy = "CUSTOM_POLICY"
        public var description: String { return self.rawValue }
    }

    public enum RecorderStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case failure = "Failure"
        case pending = "Pending"
        case success = "Success"
        public var description: String { return self.rawValue }
    }

    public enum RemediationExecutionState: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "FAILED"
        case inProgress = "IN_PROGRESS"
        case queued = "QUEUED"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum RemediationExecutionStepState: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "FAILED"
        case pending = "PENDING"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum RemediationTargetType: String, CustomStringConvertible, Codable, _SotoSendable {
        case ssmDocument = "SSM_DOCUMENT"
        public var description: String { return self.rawValue }
    }

    public enum ResourceConfigurationSchemaType: String, CustomStringConvertible, Codable, _SotoSendable {
        case cfnResourceSchema = "CFN_RESOURCE_SCHEMA"
        public var description: String { return self.rawValue }
    }

    public enum ResourceCountGroupKey: String, CustomStringConvertible, Codable, _SotoSendable {
        case accountId = "ACCOUNT_ID"
        case awsRegion = "AWS_REGION"
        case resourceType = "RESOURCE_TYPE"
        public var description: String { return self.rawValue }
    }

    public enum ResourceEvaluationStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "FAILED"
        case inProgress = "IN_PROGRESS"
        case succeeded = "SUCCEEDED"
        public var description: String { return self.rawValue }
    }

    public enum ResourceType: String, CustomStringConvertible, Codable, _SotoSendable {
        case accessAnalyzerAnalyzer = "AWS::AccessAnalyzer::Analyzer"
        case accountPublicAccessBlock = "AWS::S3::AccountPublicAccessBlock"
        case alarm = "AWS::CloudWatch::Alarm"
        case api = "AWS::ApiGatewayV2::Api"
        case appConfigApplication = "AWS::AppConfig::Application"
        case appSyncGraphQLApi = "AWS::AppSync::GraphQLApi"
        case application = "AWS::ElasticBeanstalk::Application"
        case applicationVersion = "AWS::ElasticBeanstalk::ApplicationVersion"
        case associationCompliance = "AWS::SSM::AssociationCompliance"
        case athenaDataCatalog = "AWS::Athena::DataCatalog"
        case athenaWorkGroup = "AWS::Athena::WorkGroup"
        case autoScalingGroup = "AWS::AutoScaling::AutoScalingGroup"
        case backupPlan = "AWS::Backup::BackupPlan"
        case backupRecoveryPoint = "AWS::Backup::RecoveryPoint"
        case backupSelection = "AWS::Backup::BackupSelection"
        case backupVault = "AWS::Backup::BackupVault"
        case batchComputeEnvironment = "AWS::Batch::ComputeEnvironment"
        case batchJobQueue = "AWS::Batch::JobQueue"
        case bucket = "AWS::S3::Bucket"
        case certificate = "AWS::ACM::Certificate"
        case cloudFormationProduct = "AWS::ServiceCatalog::CloudFormationProduct"
        case cloudFormationProvisionedProduct = "AWS::ServiceCatalog::CloudFormationProvisionedProduct"
        case cluster = "AWS::Redshift::Cluster"
        case clusterParameterGroup = "AWS::Redshift::ClusterParameterGroup"
        case clusterSecurityGroup = "AWS::Redshift::ClusterSecurityGroup"
        case clusterSnapshot = "AWS::Redshift::ClusterSnapshot"
        case clusterSubnetGroup = "AWS::Redshift::ClusterSubnetGroup"
        case codeDeployApplication = "AWS::CodeDeploy::Application"
        case codeDeployDeploymentConfig = "AWS::CodeDeploy::DeploymentConfig"
        case codeDeployDeploymentGroup = "AWS::CodeDeploy::DeploymentGroup"
        case conformancePackCompliance = "AWS::Config::ConformancePackCompliance"
        case customerGateway = "AWS::EC2::CustomerGateway"
        case dataSyncLocationEFS = "AWS::DataSync::LocationEFS"
        case dataSyncLocationFSxLustre = "AWS::DataSync::LocationFSxLustre"
        case dataSyncLocationNFS = "AWS::DataSync::LocationNFS"
        case dataSyncLocationS3 = "AWS::DataSync::LocationS3"
        case dataSyncLocationSMB = "AWS::DataSync::LocationSMB"
        case dataSyncTask = "AWS::DataSync::Task"
        case dbCluster = "AWS::RDS::DBCluster"
        case dbClusterSnapshot = "AWS::RDS::DBClusterSnapshot"
        case dbInstance = "AWS::RDS::DBInstance"
        case dbSecurityGroup = "AWS::RDS::DBSecurityGroup"
        case dbSnapshot = "AWS::RDS::DBSnapshot"
        case dbSubnetGroup = "AWS::RDS::DBSubnetGroup"
        case detectiveGraph = "AWS::Detective::Graph"
        case distribution = "AWS::CloudFront::Distribution"
        case dmsCertificate = "AWS::DMS::Certificate"
        case dmsEventSubscription = "AWS::DMS::EventSubscription"
        case dmsReplicationSubnetGroup = "AWS::DMS::ReplicationSubnetGroup"
        case domain = "AWS::Elasticsearch::Domain"
        case ecrPublicRepository = "AWS::ECR::PublicRepository"
        case ecrRepository = "AWS::ECR::Repository"
        case ecsCluster = "AWS::ECS::Cluster"
        case ecsService = "AWS::ECS::Service"
        case ecsTaskDefinition = "AWS::ECS::TaskDefinition"
        case efsAccessPoint = "AWS::EFS::AccessPoint"
        case efsFileSystem = "AWS::EFS::FileSystem"
        case egressOnlyInternetGateway = "AWS::EC2::EgressOnlyInternetGateway"
        case eip = "AWS::EC2::EIP"
        case eksCluster = "AWS::EKS::Cluster"
        case eksFargateProfile = "AWS::EKS::FargateProfile"
        case emrSecurityConfiguration = "AWS::EMR::SecurityConfiguration"
        case encryptionConfig = "AWS::XRay::EncryptionConfig"
        case environment = "AWS::ElasticBeanstalk::Environment"
        case eventSubscription = "AWS::RDS::EventSubscription"
        case fileData = "AWS::SSM::FileData"
        case flowLog = "AWS::EC2::FlowLog"
        case function = "AWS::Lambda::Function"
        case globalAcceleratorAccelerator = "AWS::GlobalAccelerator::Accelerator"
        case globalAcceleratorEndpointGroup = "AWS::GlobalAccelerator::EndpointGroup"
        case globalAcceleratorListener = "AWS::GlobalAccelerator::Listener"
        case glueJob = "AWS::Glue::Job"
        case group = "AWS::IAM::Group"
        case guardDutyDetector = "AWS::GuardDuty::Detector"
        case guardDutyIPSet = "AWS::GuardDuty::IPSet"
        case guardDutyThreatIntelSet = "AWS::GuardDuty::ThreatIntelSet"
        case host = "AWS::EC2::Host"
        case instance = "AWS::EC2::Instance"
        case internetGateway = "AWS::EC2::InternetGateway"
        case ipSetV2 = "AWS::WAFv2::IPSet"
        case key = "AWS::KMS::Key"
        case kinesisStream = "AWS::Kinesis::Stream"
        case kinesisStreamConsumer = "AWS::Kinesis::StreamConsumer"
        case launchConfiguration = "AWS::AutoScaling::LaunchConfiguration"
        case launchTemplate = "AWS::EC2::LaunchTemplate"
        case listenerV2 = "AWS::ElasticLoadBalancingV2::Listener"
        case loadBalancer = "AWS::ElasticLoadBalancing::LoadBalancer"
        case loadBalancerV2 = "AWS::ElasticLoadBalancingV2::LoadBalancer"
        case managedInstanceInventory = "AWS::SSM::ManagedInstanceInventory"
        case managedRuleSetV2 = "AWS::WAFv2::ManagedRuleSet"
        case mskCluster = "AWS::MSK::Cluster"
        case natGateway = "AWS::EC2::NatGateway"
        case networkAcl = "AWS::EC2::NetworkAcl"
        case networkFirewallFirewall = "AWS::NetworkFirewall::Firewall"
        case networkFirewallFirewallPolicy = "AWS::NetworkFirewall::FirewallPolicy"
        case networkFirewallRuleGroup = "AWS::NetworkFirewall::RuleGroup"
        case networkInsightsAccessScopeAnalysis = "AWS::EC2::NetworkInsightsAccessScopeAnalysis"
        case networkInterface = "AWS::EC2::NetworkInterface"
        case openSearchDomain = "AWS::OpenSearch::Domain"
        case patchCompliance = "AWS::SSM::PatchCompliance"
        case pipeline = "AWS::CodePipeline::Pipeline"
        case policy = "AWS::IAM::Policy"
        case portfolio = "AWS::ServiceCatalog::Portfolio"
        case project = "AWS::CodeBuild::Project"
        case protection = "AWS::Shield::Protection"
        case qldbLedger = "AWS::QLDB::Ledger"
        case queue = "AWS::SQS::Queue"
        case rateBasedRule = "AWS::WAF::RateBasedRule"
        case redshiftEventSubscription = "AWS::Redshift::EventSubscription"
        case regexPatternSetV2 = "AWS::WAFv2::RegexPatternSet"
        case regionalProtection = "AWS::ShieldRegional::Protection"
        case regionalRateBasedRule = "AWS::WAFRegional::RateBasedRule"
        case regionalRule = "AWS::WAFRegional::Rule"
        case regionalRuleGroup = "AWS::WAFRegional::RuleGroup"
        case regionalWebACL = "AWS::WAFRegional::WebACL"
        case registeredHAInstance = "AWS::EC2::RegisteredHAInstance"
        case resourceCompliance = "AWS::Config::ResourceCompliance"
        case restApi = "AWS::ApiGateway::RestApi"
        case role = "AWS::IAM::Role"
        case route53HostedZone = "AWS::Route53::HostedZone"
        case route53ResolverResolverEndpoint = "AWS::Route53Resolver::ResolverEndpoint"
        case route53ResolverResolverRule = "AWS::Route53Resolver::ResolverRule"
        case route53ResolverResolverRuleAssociation = "AWS::Route53Resolver::ResolverRuleAssociation"
        case routeTable = "AWS::EC2::RouteTable"
        case rule = "AWS::WAF::Rule"
        case ruleGroup = "AWS::WAF::RuleGroup"
        case ruleGroupV2 = "AWS::WAFv2::RuleGroup"
        case sageMakerCodeRepository = "AWS::SageMaker::CodeRepository"
        case sageMakerModel = "AWS::SageMaker::Model"
        case sageMakerNotebookInstanceLifecycleConfig = "AWS::SageMaker::NotebookInstanceLifecycleConfig"
        case sageMakerWorkteam = "AWS::SageMaker::Workteam"
        case scalingPolicy = "AWS::AutoScaling::ScalingPolicy"
        case scheduledAction = "AWS::AutoScaling::ScheduledAction"
        case secret = "AWS::SecretsManager::Secret"
        case securityGroup = "AWS::EC2::SecurityGroup"
        case serviceDiscoveryPublicDnsNamespace = "AWS::ServiceDiscovery::PublicDnsNamespace"
        case serviceDiscoveryService = "AWS::ServiceDiscovery::Service"
        case sesConfigurationSet = "AWS::SES::ConfigurationSet"
        case sesContactList = "AWS::SES::ContactList"
        case stack = "AWS::CloudFormation::Stack"
        case stage = "AWS::ApiGateway::Stage"
        case stageV2 = "AWS::ApiGatewayV2::Stage"
        case stepFunctionsActivity = "AWS::StepFunctions::Activity"
        case stepFunctionsStateMachine = "AWS::StepFunctions::StateMachine"
        case streamingDistribution = "AWS::CloudFront::StreamingDistribution"
        case subnet = "AWS::EC2::Subnet"
        case table = "AWS::DynamoDB::Table"
        case topic = "AWS::SNS::Topic"
        case trail = "AWS::CloudTrail::Trail"
        case transitGateway = "AWS::EC2::TransitGateway"
        case transitGatewayAttachment = "AWS::EC2::TransitGatewayAttachment"
        case transitGatewayRouteTable = "AWS::EC2::TransitGatewayRouteTable"
        case user = "AWS::IAM::User"
        case volume = "AWS::EC2::Volume"
        case vpc = "AWS::EC2::VPC"
        case vpcEndpoint = "AWS::EC2::VPCEndpoint"
        case vpcEndpointService = "AWS::EC2::VPCEndpointService"
        case vpcPeeringConnection = "AWS::EC2::VPCPeeringConnection"
        case vpnConnection = "AWS::EC2::VPNConnection"
        case vpnGateway = "AWS::EC2::VPNGateway"
        case webACL = "AWS::WAF::WebACL"
        case webACLV2 = "AWS::WAFv2::WebACL"
        case workSpacesConnectionAlias = "AWS::WorkSpaces::ConnectionAlias"
        case workSpacesWorkspace = "AWS::WorkSpaces::Workspace"
        public var description: String { return self.rawValue }
    }

    public enum ResourceValueType: String, CustomStringConvertible, Codable, _SotoSendable {
        case resourceId = "RESOURCE_ID"
        public var description: String { return self.rawValue }
    }

    public enum SortBy: String, CustomStringConvertible, Codable, _SotoSendable {
        case score = "SCORE"
        public var description: String { return self.rawValue }
    }

    public enum SortOrder: String, CustomStringConvertible, Codable, _SotoSendable {
        case ascending = "ASCENDING"
        case descending = "DESCENDING"
        public var description: String { return self.rawValue }
    }

    // MARK: Shapes

    public struct AccountAggregationSource: AWSEncodableShape & AWSDecodableShape {
        /// The 12-digit account ID of the account being aggregated.
        ///
        public let accountIds: [String]
        /// If true, aggregate existing Config regions and future
        /// 			regions.
        public let allAwsRegions: Bool?
        /// The source regions being aggregated.
        public let awsRegions: [String]?

        public init(accountIds: [String], allAwsRegions: Bool? = nil, awsRegions: [String]? = nil) {
            self.accountIds = accountIds
            self.allAwsRegions = allAwsRegions
            self.awsRegions = awsRegions
        }

        public func validate(name: String) throws {
            try self.accountIds.forEach {
                try validate($0, name: "accountIds[]", parent: name, pattern: "^\\d{12}$")
            }
            try self.validate(self.accountIds, name: "accountIds", parent: name, min: 1)
            try self.validate(self.awsRegions, name: "awsRegions", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accountIds = "AccountIds"
            case allAwsRegions = "AllAwsRegions"
            case awsRegions = "AwsRegions"
        }
    }

    public struct AggregateComplianceByConfigRule: AWSDecodableShape {
        /// The 12-digit account ID of the source account.
        public let accountId: String?
        /// The source region from where the data is aggregated.
        public let awsRegion: String?
        /// Indicates whether an Amazon Web Services resource or Config rule is
        /// 			compliant and provides the number of contributors that affect the
        /// 			compliance.
        public let compliance: Compliance?
        /// The name of the Config rule.
        public let configRuleName: String?

        public init(accountId: String? = nil, awsRegion: String? = nil, compliance: Compliance? = nil, configRuleName: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
            self.compliance = compliance
            self.configRuleName = configRuleName
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
            case compliance = "Compliance"
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct AggregateComplianceByConformancePack: AWSDecodableShape {
        /// The 12-digit Amazon Web Services account ID of the source account.
        public let accountId: String?
        /// The source Amazon Web Services Region from where the data is aggregated.
        public let awsRegion: String?
        /// The compliance status of the conformance pack.
        public let compliance: AggregateConformancePackCompliance?
        /// The name of the conformance pack.
        public let conformancePackName: String?

        public init(accountId: String? = nil, awsRegion: String? = nil, compliance: AggregateConformancePackCompliance? = nil, conformancePackName: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
            self.compliance = compliance
            self.conformancePackName = conformancePackName
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
            case compliance = "Compliance"
            case conformancePackName = "ConformancePackName"
        }
    }

    public struct AggregateComplianceCount: AWSDecodableShape {
        /// The number of compliant and noncompliant Config
        /// 			rules.
        public let complianceSummary: ComplianceSummary?
        /// The 12-digit account ID or region based on the GroupByKey
        /// 			value.
        public let groupName: String?

        public init(complianceSummary: ComplianceSummary? = nil, groupName: String? = nil) {
            self.complianceSummary = complianceSummary
            self.groupName = groupName
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummary = "ComplianceSummary"
            case groupName = "GroupName"
        }
    }

    public struct AggregateConformancePackCompliance: AWSDecodableShape {
        /// The compliance status of the conformance pack.
        public let complianceType: ConformancePackComplianceType?
        /// The number of compliant Config Rules.
        public let compliantRuleCount: Int?
        /// The number of noncompliant Config Rules.
        public let nonCompliantRuleCount: Int?
        /// Total number of compliant rules, noncompliant rules, and the rules that do not have any applicable resources to evaluate upon resulting in insufficient data.
        public let totalRuleCount: Int?

        public init(complianceType: ConformancePackComplianceType? = nil, compliantRuleCount: Int? = nil, nonCompliantRuleCount: Int? = nil, totalRuleCount: Int? = nil) {
            self.complianceType = complianceType
            self.compliantRuleCount = compliantRuleCount
            self.nonCompliantRuleCount = nonCompliantRuleCount
            self.totalRuleCount = totalRuleCount
        }

        private enum CodingKeys: String, CodingKey {
            case complianceType = "ComplianceType"
            case compliantRuleCount = "CompliantRuleCount"
            case nonCompliantRuleCount = "NonCompliantRuleCount"
            case totalRuleCount = "TotalRuleCount"
        }
    }

    public struct AggregateConformancePackComplianceCount: AWSDecodableShape {
        /// Number of compliant conformance packs.
        public let compliantConformancePackCount: Int?
        /// Number of noncompliant conformance packs.
        public let nonCompliantConformancePackCount: Int?

        public init(compliantConformancePackCount: Int? = nil, nonCompliantConformancePackCount: Int? = nil) {
            self.compliantConformancePackCount = compliantConformancePackCount
            self.nonCompliantConformancePackCount = nonCompliantConformancePackCount
        }

        private enum CodingKeys: String, CodingKey {
            case compliantConformancePackCount = "CompliantConformancePackCount"
            case nonCompliantConformancePackCount = "NonCompliantConformancePackCount"
        }
    }

    public struct AggregateConformancePackComplianceFilters: AWSEncodableShape {
        /// The 12-digit Amazon Web Services account ID of the source account.
        public let accountId: String?
        /// The source Amazon Web Services Region from where the data is aggregated.
        public let awsRegion: String?
        /// The compliance status of the conformance pack.
        public let complianceType: ConformancePackComplianceType?
        /// The name of the conformance pack.
        public let conformancePackName: String?

        public init(accountId: String? = nil, awsRegion: String? = nil, complianceType: ConformancePackComplianceType? = nil, conformancePackName: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
            self.complianceType = complianceType
            self.conformancePackName = conformancePackName
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, max: 64)
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, max: 256)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
            case complianceType = "ComplianceType"
            case conformancePackName = "ConformancePackName"
        }
    }

    public struct AggregateConformancePackComplianceSummary: AWSDecodableShape {
        /// Returns an AggregateConformancePackComplianceCount object.
        public let complianceSummary: AggregateConformancePackComplianceCount?
        /// Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.
        public let groupName: String?

        public init(complianceSummary: AggregateConformancePackComplianceCount? = nil, groupName: String? = nil) {
            self.complianceSummary = complianceSummary
            self.groupName = groupName
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummary = "ComplianceSummary"
            case groupName = "GroupName"
        }
    }

    public struct AggregateConformancePackComplianceSummaryFilters: AWSEncodableShape {
        /// The 12-digit Amazon Web Services account ID of the source account.
        public let accountId: String?
        /// The source Amazon Web Services Region from where the data is aggregated.
        public let awsRegion: String?

        public init(accountId: String? = nil, awsRegion: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, max: 64)
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
        }
    }

    public struct AggregateEvaluationResult: AWSDecodableShape {
        /// The 12-digit account ID of the source account.
        public let accountId: String?
        /// Supplementary information about how the agrregate evaluation
        /// 			determined the compliance.
        public let annotation: String?
        /// The source region from where the data is aggregated.
        public let awsRegion: String?
        /// The resource compliance status.
        /// 		       For the AggregationEvaluationResult data type, Config supports only the COMPLIANT and
        /// 				NON_COMPLIANT. Config does not support the
        /// 				NOT_APPLICABLE and INSUFFICIENT_DATA
        /// 			value.
        public let complianceType: ComplianceType?
        /// The time when the Config rule evaluated the Amazon Web Services
        /// 			resource.
        public let configRuleInvokedTime: Date?
        /// Uniquely identifies the evaluation result.
        public let evaluationResultIdentifier: EvaluationResultIdentifier?
        /// The time when Config recorded the aggregate evaluation
        /// 			result.
        public let resultRecordedTime: Date?

        public init(accountId: String? = nil, annotation: String? = nil, awsRegion: String? = nil, complianceType: ComplianceType? = nil, configRuleInvokedTime: Date? = nil, evaluationResultIdentifier: EvaluationResultIdentifier? = nil, resultRecordedTime: Date? = nil) {
            self.accountId = accountId
            self.annotation = annotation
            self.awsRegion = awsRegion
            self.complianceType = complianceType
            self.configRuleInvokedTime = configRuleInvokedTime
            self.evaluationResultIdentifier = evaluationResultIdentifier
            self.resultRecordedTime = resultRecordedTime
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case annotation = "Annotation"
            case awsRegion = "AwsRegion"
            case complianceType = "ComplianceType"
            case configRuleInvokedTime = "ConfigRuleInvokedTime"
            case evaluationResultIdentifier = "EvaluationResultIdentifier"
            case resultRecordedTime = "ResultRecordedTime"
        }
    }

    public struct AggregateResourceIdentifier: AWSEncodableShape & AWSDecodableShape {
        /// The ID of the Amazon Web Services resource.
        public let resourceId: String
        /// The name of the Amazon Web Services resource.
        public let resourceName: String?
        /// The type of the Amazon Web Services resource.
        public let resourceType: ResourceType
        /// The 12-digit account ID of the source account.
        public let sourceAccountId: String
        /// The source region where data is aggregated.
        public let sourceRegion: String

        public init(resourceId: String, resourceName: String? = nil, resourceType: ResourceType, sourceAccountId: String, sourceRegion: String) {
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.sourceAccountId = sourceAccountId
            self.sourceRegion = sourceRegion
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.sourceAccountId, name: "sourceAccountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.sourceRegion, name: "sourceRegion", parent: name, max: 64)
            try self.validate(self.sourceRegion, name: "sourceRegion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceId = "ResourceId"
            case resourceName = "ResourceName"
            case resourceType = "ResourceType"
            case sourceAccountId = "SourceAccountId"
            case sourceRegion = "SourceRegion"
        }
    }

    public struct AggregatedSourceStatus: AWSDecodableShape {
        /// The region authorized to collect aggregated data.
        public let awsRegion: String?
        /// The error code that Config returned when the source account
        /// 			aggregation last failed.
        public let lastErrorCode: String?
        /// The message indicating that the source account aggregation
        /// 			failed due to an error.
        public let lastErrorMessage: String?
        /// Filters the last updated status type.
        ///
        /// 				           Valid value FAILED indicates errors while moving
        /// 					data.
        ///
        /// 				           Valid value SUCCEEDED indicates the data was
        /// 					successfully moved.
        ///
        /// 				           Valid value OUTDATED indicates the data is not the most
        /// 					recent.
        ///
        public let lastUpdateStatus: AggregatedSourceStatusType?
        /// The time of the last update.
        public let lastUpdateTime: Date?
        /// The source account ID or an organization.
        public let sourceId: String?
        /// The source account or an organization.
        public let sourceType: AggregatedSourceType?

        public init(awsRegion: String? = nil, lastErrorCode: String? = nil, lastErrorMessage: String? = nil, lastUpdateStatus: AggregatedSourceStatusType? = nil, lastUpdateTime: Date? = nil, sourceId: String? = nil, sourceType: AggregatedSourceType? = nil) {
            self.awsRegion = awsRegion
            self.lastErrorCode = lastErrorCode
            self.lastErrorMessage = lastErrorMessage
            self.lastUpdateStatus = lastUpdateStatus
            self.lastUpdateTime = lastUpdateTime
            self.sourceId = sourceId
            self.sourceType = sourceType
        }

        private enum CodingKeys: String, CodingKey {
            case awsRegion = "AwsRegion"
            case lastErrorCode = "LastErrorCode"
            case lastErrorMessage = "LastErrorMessage"
            case lastUpdateStatus = "LastUpdateStatus"
            case lastUpdateTime = "LastUpdateTime"
            case sourceId = "SourceId"
            case sourceType = "SourceType"
        }
    }

    public struct AggregationAuthorization: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the aggregation
        /// 			object.
        public let aggregationAuthorizationArn: String?
        /// The 12-digit account ID of the account authorized to aggregate
        /// 			data.
        public let authorizedAccountId: String?
        /// The region authorized to collect aggregated data.
        public let authorizedAwsRegion: String?
        /// The time stamp when the aggregation authorization was
        /// 			created.
        public let creationTime: Date?

        public init(aggregationAuthorizationArn: String? = nil, authorizedAccountId: String? = nil, authorizedAwsRegion: String? = nil, creationTime: Date? = nil) {
            self.aggregationAuthorizationArn = aggregationAuthorizationArn
            self.authorizedAccountId = authorizedAccountId
            self.authorizedAwsRegion = authorizedAwsRegion
            self.creationTime = creationTime
        }

        private enum CodingKeys: String, CodingKey {
            case aggregationAuthorizationArn = "AggregationAuthorizationArn"
            case authorizedAccountId = "AuthorizedAccountId"
            case authorizedAwsRegion = "AuthorizedAwsRegion"
            case creationTime = "CreationTime"
        }
    }

    public struct BaseConfigurationItem: AWSDecodableShape {
        /// The 12-digit Amazon Web Services account ID associated with the resource.
        public let accountId: String?
        /// The Amazon Resource Name (ARN) of the resource.
        public let arn: String?
        /// The Availability Zone associated with the resource.
        public let availabilityZone: String?
        /// The region where the resource resides.
        public let awsRegion: String?
        /// The description of the resource configuration.
        public let configuration: String?
        /// The time when the configuration recording was initiated.
        public let configurationItemCaptureTime: Date?
        /// The configuration item status. The valid values are:
        ///
        /// 		         OK – The resource configuration has been updated   ResourceDiscovered – The resource was newly discovered   ResourceNotRecorded – The resource was discovered but its configuration was not recorded since the recorder excludes the recording of resources of this type   ResourceDeleted – The resource was deleted   ResourceDeletedNotRecorded – The resource was deleted but its configuration was not recorded since the recorder excludes the recording of resources of this type
        /// 		        The CIs do not incur any cost.
        public let configurationItemStatus: ConfigurationItemStatus?
        /// An identifier that indicates the ordering of the configuration
        /// 			items of a resource.
        public let configurationStateId: String?
        /// The time stamp when the resource was created.
        public let resourceCreationTime: Date?
        /// The ID of the resource (for example., sg-xxxxxx).
        public let resourceId: String?
        /// The custom name of the resource, if available.
        public let resourceName: String?
        /// The type of Amazon Web Services resource.
        public let resourceType: ResourceType?
        /// Configuration attributes that Config returns for certain
        /// 			resource types to supplement the information returned for the
        /// 			configuration parameter.
        public let supplementaryConfiguration: [String: String]?
        /// The version number of the resource configuration.
        public let version: String?

        public init(accountId: String? = nil, arn: String? = nil, availabilityZone: String? = nil, awsRegion: String? = nil, configuration: String? = nil, configurationItemCaptureTime: Date? = nil, configurationItemStatus: ConfigurationItemStatus? = nil, configurationStateId: String? = nil, resourceCreationTime: Date? = nil, resourceId: String? = nil, resourceName: String? = nil, resourceType: ResourceType? = nil, supplementaryConfiguration: [String: String]? = nil, version: String? = nil) {
            self.accountId = accountId
            self.arn = arn
            self.availabilityZone = availabilityZone
            self.awsRegion = awsRegion
            self.configuration = configuration
            self.configurationItemCaptureTime = configurationItemCaptureTime
            self.configurationItemStatus = configurationItemStatus
            self.configurationStateId = configurationStateId
            self.resourceCreationTime = resourceCreationTime
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.supplementaryConfiguration = supplementaryConfiguration
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case accountId
            case arn
            case availabilityZone
            case awsRegion
            case configuration
            case configurationItemCaptureTime
            case configurationItemStatus
            case configurationStateId
            case resourceCreationTime
            case resourceId
            case resourceName
            case resourceType
            case supplementaryConfiguration
            case version
        }
    }

    public struct BatchGetAggregateResourceConfigRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// A list of aggregate ResourceIdentifiers objects.
        public let resourceIdentifiers: [AggregateResourceIdentifier]

        public init(configurationAggregatorName: String, resourceIdentifiers: [AggregateResourceIdentifier]) {
            self.configurationAggregatorName = configurationAggregatorName
            self.resourceIdentifiers = resourceIdentifiers
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.resourceIdentifiers.forEach {
                try $0.validate(name: "\(name).resourceIdentifiers[]")
            }
            try self.validate(self.resourceIdentifiers, name: "resourceIdentifiers", parent: name, max: 100)
            try self.validate(self.resourceIdentifiers, name: "resourceIdentifiers", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case resourceIdentifiers = "ResourceIdentifiers"
        }
    }

    public struct BatchGetAggregateResourceConfigResponse: AWSDecodableShape {
        /// A list that contains the current configuration of one or more resources.
        public let baseConfigurationItems: [BaseConfigurationItem]?
        /// A list of resource identifiers that were not processed with current scope. The list is empty if all the resources are processed.
        public let unprocessedResourceIdentifiers: [AggregateResourceIdentifier]?

        public init(baseConfigurationItems: [BaseConfigurationItem]? = nil, unprocessedResourceIdentifiers: [AggregateResourceIdentifier]? = nil) {
            self.baseConfigurationItems = baseConfigurationItems
            self.unprocessedResourceIdentifiers = unprocessedResourceIdentifiers
        }

        private enum CodingKeys: String, CodingKey {
            case baseConfigurationItems = "BaseConfigurationItems"
            case unprocessedResourceIdentifiers = "UnprocessedResourceIdentifiers"
        }
    }

    public struct BatchGetResourceConfigRequest: AWSEncodableShape {
        /// A list of resource keys to be processed with the current
        /// 			request. Each element in the list consists of the resource type and
        /// 			resource ID.
        public let resourceKeys: [ResourceKey]

        public init(resourceKeys: [ResourceKey]) {
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.resourceKeys.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceKeys
        }
    }

    public struct BatchGetResourceConfigResponse: AWSDecodableShape {
        /// A list that contains the current configuration of one or more
        /// 			resources.
        public let baseConfigurationItems: [BaseConfigurationItem]?
        /// A list of resource keys that were not processed with the
        /// 			current response. The unprocessesResourceKeys value is in the same
        /// 			form as ResourceKeys, so the value can be directly provided to a
        /// 			subsequent BatchGetResourceConfig operation.
        ///
        /// 			If there are no unprocessed resource keys, the response contains an
        /// 			empty unprocessedResourceKeys list.
        public let unprocessedResourceKeys: [ResourceKey]?

        public init(baseConfigurationItems: [BaseConfigurationItem]? = nil, unprocessedResourceKeys: [ResourceKey]? = nil) {
            self.baseConfigurationItems = baseConfigurationItems
            self.unprocessedResourceKeys = unprocessedResourceKeys
        }

        private enum CodingKeys: String, CodingKey {
            case baseConfigurationItems
            case unprocessedResourceKeys
        }
    }

    public struct Compliance: AWSDecodableShape {
        /// The number of Amazon Web Services resources or Config rules that cause a
        /// 			result of NON_COMPLIANT, up to a maximum
        /// 			number.
        public let complianceContributorCount: ComplianceContributorCount?
        /// Indicates whether an Amazon Web Services resource or Config rule is
        /// 			compliant.
        /// 		       A resource is compliant if it complies with all of the Config rules that evaluate it. A resource is noncompliant if it does
        /// 			not comply with one or more of these rules.
        /// 		       A rule is compliant if all of the resources that the rule
        /// 			evaluates comply with it. A rule is noncompliant if any of these
        /// 			resources do not comply.
        /// 		       Config returns the INSUFFICIENT_DATA value
        /// 			when no evaluation results are available for the Amazon Web Services resource or Config rule.
        /// 		       For the Compliance data type, Config supports
        /// 			only COMPLIANT, NON_COMPLIANT, and
        /// 				INSUFFICIENT_DATA values. Config does not
        /// 			support the NOT_APPLICABLE value for the
        /// 				Compliance data type.
        public let complianceType: ComplianceType?

        public init(complianceContributorCount: ComplianceContributorCount? = nil, complianceType: ComplianceType? = nil) {
            self.complianceContributorCount = complianceContributorCount
            self.complianceType = complianceType
        }

        private enum CodingKeys: String, CodingKey {
            case complianceContributorCount = "ComplianceContributorCount"
            case complianceType = "ComplianceType"
        }
    }

    public struct ComplianceByConfigRule: AWSDecodableShape {
        /// Indicates whether the Config rule is compliant.
        public let compliance: Compliance?
        /// The name of the Config rule.
        public let configRuleName: String?

        public init(compliance: Compliance? = nil, configRuleName: String? = nil) {
            self.compliance = compliance
            self.configRuleName = configRuleName
        }

        private enum CodingKeys: String, CodingKey {
            case compliance = "Compliance"
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct ComplianceByResource: AWSDecodableShape {
        /// Indicates whether the Amazon Web Services resource complies with all of the Config rules that evaluated it.
        public let compliance: Compliance?
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let resourceId: String?
        /// The type of the Amazon Web Services resource that was evaluated.
        public let resourceType: String?

        public init(compliance: Compliance? = nil, resourceId: String? = nil, resourceType: String? = nil) {
            self.compliance = compliance
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case compliance = "Compliance"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct ComplianceContributorCount: AWSDecodableShape {
        /// Indicates whether the maximum count is reached.
        public let capExceeded: Bool?
        /// The number of Amazon Web Services resources or Config rules responsible for
        /// 			the current compliance of the item.
        public let cappedCount: Int?

        public init(capExceeded: Bool? = nil, cappedCount: Int? = nil) {
            self.capExceeded = capExceeded
            self.cappedCount = cappedCount
        }

        private enum CodingKeys: String, CodingKey {
            case capExceeded = "CapExceeded"
            case cappedCount = "CappedCount"
        }
    }

    public struct ComplianceSummary: AWSDecodableShape {
        /// The time that Config created the compliance
        /// 			summary.
        public let complianceSummaryTimestamp: Date?
        /// The number of Config rules or Amazon Web Services resources that are
        /// 			compliant, up to a maximum of 25 for rules and 100 for
        /// 			resources.
        public let compliantResourceCount: ComplianceContributorCount?
        /// The number of Config rules or Amazon Web Services resources that are
        /// 			noncompliant, up to a maximum of 25 for rules and 100 for
        /// 			resources.
        public let nonCompliantResourceCount: ComplianceContributorCount?

        public init(complianceSummaryTimestamp: Date? = nil, compliantResourceCount: ComplianceContributorCount? = nil, nonCompliantResourceCount: ComplianceContributorCount? = nil) {
            self.complianceSummaryTimestamp = complianceSummaryTimestamp
            self.compliantResourceCount = compliantResourceCount
            self.nonCompliantResourceCount = nonCompliantResourceCount
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummaryTimestamp = "ComplianceSummaryTimestamp"
            case compliantResourceCount = "CompliantResourceCount"
            case nonCompliantResourceCount = "NonCompliantResourceCount"
        }
    }

    public struct ComplianceSummaryByResourceType: AWSDecodableShape {
        /// The number of Amazon Web Services resources that are compliant or noncompliant,
        /// 			up to a maximum of 100 for each.
        public let complianceSummary: ComplianceSummary?
        /// The type of Amazon Web Services resource.
        public let resourceType: String?

        public init(complianceSummary: ComplianceSummary? = nil, resourceType: String? = nil) {
            self.complianceSummary = complianceSummary
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummary = "ComplianceSummary"
            case resourceType = "ResourceType"
        }
    }

    public struct ConfigExportDeliveryInfo: AWSDecodableShape {
        /// The time of the last attempted delivery.
        public let lastAttemptTime: Date?
        /// The error code from the last attempted delivery.
        public let lastErrorCode: String?
        /// The error message from the last attempted delivery.
        public let lastErrorMessage: String?
        /// Status of the last attempted delivery.
        public let lastStatus: DeliveryStatus?
        /// The time of the last successful delivery.
        public let lastSuccessfulTime: Date?
        /// The time that the next delivery occurs.
        public let nextDeliveryTime: Date?

        public init(lastAttemptTime: Date? = nil, lastErrorCode: String? = nil, lastErrorMessage: String? = nil, lastStatus: DeliveryStatus? = nil, lastSuccessfulTime: Date? = nil, nextDeliveryTime: Date? = nil) {
            self.lastAttemptTime = lastAttemptTime
            self.lastErrorCode = lastErrorCode
            self.lastErrorMessage = lastErrorMessage
            self.lastStatus = lastStatus
            self.lastSuccessfulTime = lastSuccessfulTime
            self.nextDeliveryTime = nextDeliveryTime
        }

        private enum CodingKeys: String, CodingKey {
            case lastAttemptTime
            case lastErrorCode
            case lastErrorMessage
            case lastStatus
            case lastSuccessfulTime
            case nextDeliveryTime
        }
    }

    public struct ConfigRule: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Config
        /// 			rule.
        public let configRuleArn: String?
        /// The ID of the Config rule.
        public let configRuleId: String?
        /// The name that you assign to the Config rule. The name is
        /// 			required if you are adding a new rule.
        public let configRuleName: String?
        /// Indicates whether the Config rule is active or is currently
        /// 			being deleted by Config. It can also indicate the evaluation
        /// 			status for the Config rule.
        /// 		       Config sets the state of the rule to
        /// 				EVALUATING temporarily after you use the
        /// 				StartConfigRulesEvaluation request to evaluate your
        /// 			resources against the Config rule.
        /// 		       Config sets the state of the rule to
        /// 				DELETING_RESULTS temporarily after you use the
        /// 				DeleteEvaluationResults request to delete the
        /// 			current evaluation results for the Config rule.
        /// 		       Config temporarily sets the state of a rule to
        /// 				DELETING after you use the
        /// 				DeleteConfigRule request to delete the rule. After
        /// 			Config deletes the rule, the rule and all of its evaluations are
        /// 			erased and are no longer available.
        public let configRuleState: ConfigRuleState?
        /// Service principal name of the service that created the
        /// 			rule.
        ///
        /// 			         The field is populated only if the service-linked rule is
        /// 				created by a service. The field is empty if you create your own
        /// 				rule.
        ///
        public let createdBy: String?
        /// The description that you provide for the Config
        /// 			rule.
        public let description: String?
        /// The modes the Config rule can be evaluated in. The valid values are distinct objects. By default, the value is Detective evaluation mode only.
        public let evaluationModes: [EvaluationModeConfiguration]?
        /// A string, in JSON format, that is passed to the Config rule
        /// 			Lambda function.
        public let inputParameters: String?
        /// The maximum frequency with which Config runs evaluations
        /// 			for a rule. You can specify a value for
        /// 				MaximumExecutionFrequency when:
        ///
        /// 				           This is for an Config managed rule that is triggered at
        /// 					a periodic frequency.
        ///
        /// 				           Your custom rule is triggered when Config delivers
        /// 					the configuration snapshot. For more information, see ConfigSnapshotDeliveryProperties.
        ///
        ///
        /// 			         By default, rules with a periodic trigger are evaluated
        /// 				every 24 hours. To change the frequency, specify a valid value
        /// 				for the MaximumExecutionFrequency
        /// 				parameter.
        ///
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// Defines which resources can trigger an evaluation for the rule.
        /// 			The scope can include one or more resource types, a combination of
        /// 			one resource type and one resource ID, or a combination of a tag key
        /// 			and value. Specify a scope to constrain the resources that can
        /// 			trigger an evaluation for the rule. If you do not specify a scope,
        /// 			evaluations are triggered when any resource in the recording group
        /// 			changes.
        /// 		        The scope can be empty.
        public let scope: Scope?
        /// Provides the rule owner (Amazon Web Services for managed rules, CUSTOM_POLICY for Custom Policy rules, and CUSTOM_LAMBDA for Custom Lambda rules), the rule identifier,
        /// 			and the notifications that cause the function to evaluate your Amazon Web Services
        /// 			resources.
        public let source: Source

        public init(configRuleArn: String? = nil, configRuleId: String? = nil, configRuleName: String? = nil, configRuleState: ConfigRuleState? = nil, createdBy: String? = nil, description: String? = nil, evaluationModes: [EvaluationModeConfiguration]? = nil, inputParameters: String? = nil, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, scope: Scope? = nil, source: Source) {
            self.configRuleArn = configRuleArn
            self.configRuleId = configRuleId
            self.configRuleName = configRuleName
            self.configRuleState = configRuleState
            self.createdBy = createdBy
            self.description = description
            self.evaluationModes = evaluationModes
            self.inputParameters = inputParameters
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.scope = scope
            self.source = source
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleArn, name: "configRuleArn", parent: name, max: 256)
            try self.validate(self.configRuleArn, name: "configRuleArn", parent: name, min: 1)
            try self.validate(self.configRuleId, name: "configRuleId", parent: name, max: 64)
            try self.validate(self.configRuleId, name: "configRuleId", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.createdBy, name: "createdBy", parent: name, max: 256)
            try self.validate(self.createdBy, name: "createdBy", parent: name, min: 1)
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, max: 1024)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, min: 1)
            try self.scope?.validate(name: "\(name).scope")
            try self.source.validate(name: "\(name).source")
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleArn = "ConfigRuleArn"
            case configRuleId = "ConfigRuleId"
            case configRuleName = "ConfigRuleName"
            case configRuleState = "ConfigRuleState"
            case createdBy = "CreatedBy"
            case description = "Description"
            case evaluationModes = "EvaluationModes"
            case inputParameters = "InputParameters"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case scope = "Scope"
            case source = "Source"
        }
    }

    public struct ConfigRuleComplianceFilters: AWSEncodableShape {
        /// The 12-digit account ID of the source account.
        ///
        public let accountId: String?
        /// The source region where the data is aggregated.
        ///
        public let awsRegion: String?
        /// The rule compliance status.
        /// 		       For the ConfigRuleComplianceFilters data type, Config supports only COMPLIANT and
        /// 				NON_COMPLIANT. Config does not support the
        /// 				NOT_APPLICABLE and the
        /// 				INSUFFICIENT_DATA values.
        public let complianceType: ComplianceType?
        /// The name of the Config rule.
        public let configRuleName: String?

        public init(accountId: String? = nil, awsRegion: String? = nil, complianceType: ComplianceType? = nil, configRuleName: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
            self.complianceType = complianceType
            self.configRuleName = configRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, max: 64)
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
            case complianceType = "ComplianceType"
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct ConfigRuleComplianceSummaryFilters: AWSEncodableShape {
        /// The 12-digit account ID of the source account.
        public let accountId: String?
        /// The source region where the data is aggregated.
        public let awsRegion: String?

        public init(accountId: String? = nil, awsRegion: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, max: 64)
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
        }
    }

    public struct ConfigRuleEvaluationStatus: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Config
        /// 			rule.
        public let configRuleArn: String?
        /// The ID of the Config rule.
        public let configRuleId: String?
        /// The name of the Config rule.
        public let configRuleName: String?
        /// The time that you first activated the Config
        /// 			rule.
        public let firstActivatedTime: Date?
        /// Indicates whether Config has evaluated your resources
        /// 			against the rule at least once.
        ///
        ///
        /// 					             true - Config has evaluated your Amazon Web Services
        /// 					resources against the rule at least once.
        ///
        ///
        /// 					             false - Config has not finished evaluating your Amazon Web Services resources against the
        /// 					rule
        /// 					at least once.
        ///
        public let firstEvaluationStarted: Bool?
        /// The time that you last turned off the Config rule.
        public let lastDeactivatedTime: Date?
        /// The status of the last attempted delivery of a debug log for your Config Custom Policy rules. Either Successful or Failed.
        public let lastDebugLogDeliveryStatus: String?
        /// The reason Config was not able to deliver a debug log. This is for the last
        /// 			failed attempt to retrieve a debug log for your Config Custom Policy rules.
        public let lastDebugLogDeliveryStatusReason: String?
        /// The time Config last attempted to deliver a debug log for your Config Custom Policy rules.
        public let lastDebugLogDeliveryTime: Date?
        /// The error code that Config returned when the rule last
        /// 			failed.
        public let lastErrorCode: String?
        /// The error message that Config returned when the rule last
        /// 			failed.
        public let lastErrorMessage: String?
        /// The time that Config last failed to evaluate your Amazon Web Services
        /// 			resources against the rule.
        public let lastFailedEvaluationTime: Date?
        /// The time that Config last failed to invoke the Config
        /// 			rule to evaluate your Amazon Web Services resources.
        public let lastFailedInvocationTime: Date?
        /// The time that Config last successfully evaluated your Amazon Web Services
        /// 			resources against the rule.
        public let lastSuccessfulEvaluationTime: Date?
        /// The time that Config last successfully invoked the Config rule to evaluate your Amazon Web Services resources.
        public let lastSuccessfulInvocationTime: Date?

        public init(configRuleArn: String? = nil, configRuleId: String? = nil, configRuleName: String? = nil, firstActivatedTime: Date? = nil, firstEvaluationStarted: Bool? = nil, lastDeactivatedTime: Date? = nil, lastDebugLogDeliveryStatus: String? = nil, lastDebugLogDeliveryStatusReason: String? = nil, lastDebugLogDeliveryTime: Date? = nil, lastErrorCode: String? = nil, lastErrorMessage: String? = nil, lastFailedEvaluationTime: Date? = nil, lastFailedInvocationTime: Date? = nil, lastSuccessfulEvaluationTime: Date? = nil, lastSuccessfulInvocationTime: Date? = nil) {
            self.configRuleArn = configRuleArn
            self.configRuleId = configRuleId
            self.configRuleName = configRuleName
            self.firstActivatedTime = firstActivatedTime
            self.firstEvaluationStarted = firstEvaluationStarted
            self.lastDeactivatedTime = lastDeactivatedTime
            self.lastDebugLogDeliveryStatus = lastDebugLogDeliveryStatus
            self.lastDebugLogDeliveryStatusReason = lastDebugLogDeliveryStatusReason
            self.lastDebugLogDeliveryTime = lastDebugLogDeliveryTime
            self.lastErrorCode = lastErrorCode
            self.lastErrorMessage = lastErrorMessage
            self.lastFailedEvaluationTime = lastFailedEvaluationTime
            self.lastFailedInvocationTime = lastFailedInvocationTime
            self.lastSuccessfulEvaluationTime = lastSuccessfulEvaluationTime
            self.lastSuccessfulInvocationTime = lastSuccessfulInvocationTime
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleArn = "ConfigRuleArn"
            case configRuleId = "ConfigRuleId"
            case configRuleName = "ConfigRuleName"
            case firstActivatedTime = "FirstActivatedTime"
            case firstEvaluationStarted = "FirstEvaluationStarted"
            case lastDeactivatedTime = "LastDeactivatedTime"
            case lastDebugLogDeliveryStatus = "LastDebugLogDeliveryStatus"
            case lastDebugLogDeliveryStatusReason = "LastDebugLogDeliveryStatusReason"
            case lastDebugLogDeliveryTime = "LastDebugLogDeliveryTime"
            case lastErrorCode = "LastErrorCode"
            case lastErrorMessage = "LastErrorMessage"
            case lastFailedEvaluationTime = "LastFailedEvaluationTime"
            case lastFailedInvocationTime = "LastFailedInvocationTime"
            case lastSuccessfulEvaluationTime = "LastSuccessfulEvaluationTime"
            case lastSuccessfulInvocationTime = "LastSuccessfulInvocationTime"
        }
    }

    public struct ConfigSnapshotDeliveryProperties: AWSEncodableShape & AWSDecodableShape {
        /// The frequency with which Config delivers configuration
        /// 			snapshots.
        public let deliveryFrequency: MaximumExecutionFrequency?

        public init(deliveryFrequency: MaximumExecutionFrequency? = nil) {
            self.deliveryFrequency = deliveryFrequency
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryFrequency
        }
    }

    public struct ConfigStreamDeliveryInfo: AWSDecodableShape {
        /// The error code from the last attempted delivery.
        public let lastErrorCode: String?
        /// The error message from the last attempted delivery.
        public let lastErrorMessage: String?
        /// Status of the last attempted delivery.
        ///
        /// 			         Note Providing an SNS topic on a
        /// 				DeliveryChannel for Config is optional. If the SNS
        /// 			delivery is turned off, the last status will be Not_Applicable.
        public let lastStatus: DeliveryStatus?
        /// The time from the last status change.
        public let lastStatusChangeTime: Date?

        public init(lastErrorCode: String? = nil, lastErrorMessage: String? = nil, lastStatus: DeliveryStatus? = nil, lastStatusChangeTime: Date? = nil) {
            self.lastErrorCode = lastErrorCode
            self.lastErrorMessage = lastErrorMessage
            self.lastStatus = lastStatus
            self.lastStatusChangeTime = lastStatusChangeTime
        }

        private enum CodingKeys: String, CodingKey {
            case lastErrorCode
            case lastErrorMessage
            case lastStatus
            case lastStatusChangeTime
        }
    }

    public struct ConfigurationAggregator: AWSDecodableShape {
        /// Provides a list of source accounts and regions to be
        /// 			aggregated.
        public let accountAggregationSources: [AccountAggregationSource]?
        /// The Amazon Resource Name (ARN) of the aggregator.
        public let configurationAggregatorArn: String?
        /// The name of the aggregator.
        public let configurationAggregatorName: String?
        /// Amazon Web Services service that created the configuration aggregator.
        public let createdBy: String?
        /// The time stamp when the configuration aggregator was
        /// 			created.
        public let creationTime: Date?
        /// The time of the last update.
        public let lastUpdatedTime: Date?
        /// Provides an organization and list of regions to be
        /// 			aggregated.
        public let organizationAggregationSource: OrganizationAggregationSource?

        public init(accountAggregationSources: [AccountAggregationSource]? = nil, configurationAggregatorArn: String? = nil, configurationAggregatorName: String? = nil, createdBy: String? = nil, creationTime: Date? = nil, lastUpdatedTime: Date? = nil, organizationAggregationSource: OrganizationAggregationSource? = nil) {
            self.accountAggregationSources = accountAggregationSources
            self.configurationAggregatorArn = configurationAggregatorArn
            self.configurationAggregatorName = configurationAggregatorName
            self.createdBy = createdBy
            self.creationTime = creationTime
            self.lastUpdatedTime = lastUpdatedTime
            self.organizationAggregationSource = organizationAggregationSource
        }

        private enum CodingKeys: String, CodingKey {
            case accountAggregationSources = "AccountAggregationSources"
            case configurationAggregatorArn = "ConfigurationAggregatorArn"
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case createdBy = "CreatedBy"
            case creationTime = "CreationTime"
            case lastUpdatedTime = "LastUpdatedTime"
            case organizationAggregationSource = "OrganizationAggregationSource"
        }
    }

    public struct ConfigurationItem: AWSDecodableShape {
        /// The 12-digit Amazon Web Services account ID associated with the
        /// 			resource.
        public let accountId: String?
        /// Amazon Resource Name (ARN) associated with the resource.
        public let arn: String?
        /// The Availability Zone associated with the resource.
        public let availabilityZone: String?
        /// The region where the resource resides.
        public let awsRegion: String?
        /// The description of the resource configuration.
        public let configuration: String?
        /// The time when the configuration recording was
        /// 			initiated.
        public let configurationItemCaptureTime: Date?
        /// Unique MD5 hash that represents the configuration item's
        /// 			state.
        /// 		       You can use MD5 hash to compare the states of two or more
        /// 			configuration items that are associated with the same
        /// 			resource.
        public let configurationItemMD5Hash: String?
        /// The configuration item status. The valid values are:
        ///
        /// 		         OK – The resource configuration has been updated   ResourceDiscovered – The resource was newly discovered   ResourceNotRecorded – The resource was discovered but its configuration was not recorded since the recorder excludes the recording of resources of this type   ResourceDeleted – The resource was deleted   ResourceDeletedNotRecorded – The resource was deleted but its configuration was not recorded since the recorder excludes the recording of resources of this type
        /// 		        The CIs do not incur any cost.
        public let configurationItemStatus: ConfigurationItemStatus?
        /// An identifier that indicates the ordering of the configuration
        /// 			items of a resource.
        public let configurationStateId: String?
        /// A list of CloudTrail event IDs.
        /// 		       A populated field indicates that the current configuration was
        /// 			initiated by the events recorded in the CloudTrail log. For more
        /// 			information about CloudTrail, see What Is CloudTrail.
        /// 		       An empty field indicates that the current configuration was not
        /// 			initiated by any event. As of Version 1.3, the relatedEvents field is empty.
        /// 			You can access the LookupEvents API in the CloudTrail API Reference to retrieve the events for the resource.
        public let relatedEvents: [String]?
        /// A list of related Amazon Web Services resources.
        public let relationships: [Relationship]?
        /// The time stamp when the resource was created.
        public let resourceCreationTime: Date?
        /// The ID of the resource (for example,
        /// 			sg-xxxxxx).
        public let resourceId: String?
        /// The custom name of the resource, if available.
        public let resourceName: String?
        /// The type of Amazon Web Services resource.
        public let resourceType: ResourceType?
        /// Configuration attributes that Config returns for certain
        /// 			resource types to supplement the information returned for the
        /// 				configuration parameter.
        public let supplementaryConfiguration: [String: String]?
        /// A mapping of key value tags associated with the
        /// 			resource.
        public let tags: [String: String]?
        /// The version number of the resource configuration.
        public let version: String?

        public init(accountId: String? = nil, arn: String? = nil, availabilityZone: String? = nil, awsRegion: String? = nil, configuration: String? = nil, configurationItemCaptureTime: Date? = nil, configurationItemMD5Hash: String? = nil, configurationItemStatus: ConfigurationItemStatus? = nil, configurationStateId: String? = nil, relatedEvents: [String]? = nil, relationships: [Relationship]? = nil, resourceCreationTime: Date? = nil, resourceId: String? = nil, resourceName: String? = nil, resourceType: ResourceType? = nil, supplementaryConfiguration: [String: String]? = nil, tags: [String: String]? = nil, version: String? = nil) {
            self.accountId = accountId
            self.arn = arn
            self.availabilityZone = availabilityZone
            self.awsRegion = awsRegion
            self.configuration = configuration
            self.configurationItemCaptureTime = configurationItemCaptureTime
            self.configurationItemMD5Hash = configurationItemMD5Hash
            self.configurationItemStatus = configurationItemStatus
            self.configurationStateId = configurationStateId
            self.relatedEvents = relatedEvents
            self.relationships = relationships
            self.resourceCreationTime = resourceCreationTime
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.supplementaryConfiguration = supplementaryConfiguration
            self.tags = tags
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case accountId
            case arn
            case availabilityZone
            case awsRegion
            case configuration
            case configurationItemCaptureTime
            case configurationItemMD5Hash
            case configurationItemStatus
            case configurationStateId
            case relatedEvents
            case relationships
            case resourceCreationTime
            case resourceId
            case resourceName
            case resourceType
            case supplementaryConfiguration
            case tags
            case version
        }
    }

    public struct ConfigurationRecorder: AWSEncodableShape & AWSDecodableShape {
        /// The name of the recorder. By default, Config automatically
        /// 			assigns the name "default" when creating the configuration recorder.
        /// 			You cannot change the assigned name.
        public let name: String?
        /// Specifies the types of Amazon Web Services resources for which Config
        /// 			records configuration changes.
        public let recordingGroup: RecordingGroup?
        /// Amazon Resource Name (ARN) of the IAM role used to describe the
        /// 			Amazon Web Services resources associated with the account.
        /// 		        While the API model does not require this field, the server will reject a request without a defined roleARN for the configuration recorder.
        public let roleARN: String?

        public init(name: String? = nil, recordingGroup: RecordingGroup? = nil, roleARN: String? = nil) {
            self.name = name
            self.recordingGroup = recordingGroup
            self.roleARN = roleARN
        }

        public func validate(name: String) throws {
            try self.validate(self.name, name: "name", parent: name, max: 256)
            try self.validate(self.name, name: "name", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case name
            case recordingGroup
            case roleARN
        }
    }

    public struct ConfigurationRecorderStatus: AWSDecodableShape {
        /// The error code indicating that the recording failed.
        public let lastErrorCode: String?
        /// The message indicating that the recording failed due to an
        /// 			error.
        public let lastErrorMessage: String?
        /// The time the recorder was last started.
        public let lastStartTime: Date?
        /// The last (previous) status of the recorder.
        public let lastStatus: RecorderStatus?
        /// The time when the status was last changed.
        public let lastStatusChangeTime: Date?
        /// The time the recorder was last stopped.
        public let lastStopTime: Date?
        /// The name of the configuration recorder.
        public let name: String?
        /// Specifies whether or not the recorder is currently
        /// 			recording.
        public let recording: Bool?

        public init(lastErrorCode: String? = nil, lastErrorMessage: String? = nil, lastStartTime: Date? = nil, lastStatus: RecorderStatus? = nil, lastStatusChangeTime: Date? = nil, lastStopTime: Date? = nil, name: String? = nil, recording: Bool? = nil) {
            self.lastErrorCode = lastErrorCode
            self.lastErrorMessage = lastErrorMessage
            self.lastStartTime = lastStartTime
            self.lastStatus = lastStatus
            self.lastStatusChangeTime = lastStatusChangeTime
            self.lastStopTime = lastStopTime
            self.name = name
            self.recording = recording
        }

        private enum CodingKeys: String, CodingKey {
            case lastErrorCode
            case lastErrorMessage
            case lastStartTime
            case lastStatus
            case lastStatusChangeTime
            case lastStopTime
            case name
            case recording
        }
    }

    public struct ConformancePackComplianceFilters: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT and NON_COMPLIANT. INSUFFICIENT_DATA is not supported.
        public let complianceType: ConformancePackComplianceType?
        /// Filters the results by Config rule names.
        public let configRuleNames: [String]?

        public init(complianceType: ConformancePackComplianceType? = nil, configRuleNames: [String]? = nil) {
            self.complianceType = complianceType
            self.configRuleNames = configRuleNames
        }

        public func validate(name: String) throws {
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 64)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 10)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceType = "ComplianceType"
            case configRuleNames = "ConfigRuleNames"
        }
    }

    public struct ConformancePackComplianceScore: AWSDecodableShape {
        /// The name of the conformance pack.
        public let conformancePackName: String?
        /// The time that the conformance pack compliance score was last updated.
        public let lastUpdatedTime: Date?
        /// Compliance score for the conformance pack. Conformance packs with no evaluation results will have a compliance score of INSUFFICIENT_DATA.
        public let score: String?

        public init(conformancePackName: String? = nil, lastUpdatedTime: Date? = nil, score: String? = nil) {
            self.conformancePackName = conformancePackName
            self.lastUpdatedTime = lastUpdatedTime
            self.score = score
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
            case lastUpdatedTime = "LastUpdatedTime"
            case score = "Score"
        }
    }

    public struct ConformancePackComplianceScoresFilters: AWSEncodableShape {
        /// The names of the conformance packs whose compliance scores you want to include in the conformance pack compliance score result set.
        /// 			You can include up to 25 conformance packs in the ConformancePackNames array of strings, each with a character limit of 256 characters for the conformance pack name.
        public let conformancePackNames: [String]

        public init(conformancePackNames: [String]) {
            self.conformancePackNames = conformancePackNames
        }

        public func validate(name: String) throws {
            try self.conformancePackNames.forEach {
                try validate($0, name: "conformancePackNames[]", parent: name, max: 256)
                try validate($0, name: "conformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "conformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, max: 25)
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackNames = "ConformancePackNames"
        }
    }

    public struct ConformancePackComplianceSummary: AWSDecodableShape {
        /// The status of the conformance pack. The allowed values are COMPLIANT, NON_COMPLIANT and INSUFFICIENT_DATA.
        public let conformancePackComplianceStatus: ConformancePackComplianceType
        /// The name of the conformance pack name.
        public let conformancePackName: String

        public init(conformancePackComplianceStatus: ConformancePackComplianceType, conformancePackName: String) {
            self.conformancePackComplianceStatus = conformancePackComplianceStatus
            self.conformancePackName = conformancePackName
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackComplianceStatus = "ConformancePackComplianceStatus"
            case conformancePackName = "ConformancePackName"
        }
    }

    public struct ConformancePackDetail: AWSDecodableShape {
        /// Amazon Resource Name (ARN) of the conformance pack.
        public let conformancePackArn: String
        /// ID of the conformance pack.
        public let conformancePackId: String
        /// A list of ConformancePackInputParameter objects.
        public let conformancePackInputParameters: [ConformancePackInputParameter]?
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// The Amazon Web Services service that created the conformance pack.
        public let createdBy: String?
        /// The name of the Amazon S3 bucket where Config stores conformance pack templates.
        /// 	         This field is optional.
        public let deliveryS3Bucket: String?
        /// The prefix for the Amazon S3 bucket.
        /// 		        This field is optional.
        public let deliveryS3KeyPrefix: String?
        /// The last time a conformation pack update was requested.
        public let lastUpdateRequestedTime: Date?
        /// An object that contains the name or Amazon Resource Name (ARN) of the Amazon Web Services Systems Manager document (SSM document) and the version of the SSM document that is used to create a conformance pack.
        public let templateSSMDocumentDetails: TemplateSSMDocumentDetails?

        public init(conformancePackArn: String, conformancePackId: String, conformancePackInputParameters: [ConformancePackInputParameter]? = nil, conformancePackName: String, createdBy: String? = nil, deliveryS3Bucket: String? = nil, deliveryS3KeyPrefix: String? = nil, lastUpdateRequestedTime: Date? = nil, templateSSMDocumentDetails: TemplateSSMDocumentDetails? = nil) {
            self.conformancePackArn = conformancePackArn
            self.conformancePackId = conformancePackId
            self.conformancePackInputParameters = conformancePackInputParameters
            self.conformancePackName = conformancePackName
            self.createdBy = createdBy
            self.deliveryS3Bucket = deliveryS3Bucket
            self.deliveryS3KeyPrefix = deliveryS3KeyPrefix
            self.lastUpdateRequestedTime = lastUpdateRequestedTime
            self.templateSSMDocumentDetails = templateSSMDocumentDetails
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackArn = "ConformancePackArn"
            case conformancePackId = "ConformancePackId"
            case conformancePackInputParameters = "ConformancePackInputParameters"
            case conformancePackName = "ConformancePackName"
            case createdBy = "CreatedBy"
            case deliveryS3Bucket = "DeliveryS3Bucket"
            case deliveryS3KeyPrefix = "DeliveryS3KeyPrefix"
            case lastUpdateRequestedTime = "LastUpdateRequestedTime"
            case templateSSMDocumentDetails = "TemplateSSMDocumentDetails"
        }
    }

    public struct ConformancePackEvaluationFilters: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT and NON_COMPLIANT. INSUFFICIENT_DATA is not supported.
        public let complianceType: ConformancePackComplianceType?
        /// Filters the results by Config rule names.
        public let configRuleNames: [String]?
        /// Filters the results by resource IDs.
        /// 		        This is valid only when you provide resource type. If there is no resource type, you will see an error.
        public let resourceIds: [String]?
        /// Filters the results by the resource type (for example, "AWS::EC2::Instance").
        public let resourceType: String?

        public init(complianceType: ConformancePackComplianceType? = nil, configRuleNames: [String]? = nil, resourceIds: [String]? = nil, resourceType: String? = nil) {
            self.complianceType = complianceType
            self.configRuleNames = configRuleNames
            self.resourceIds = resourceIds
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 64)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 10)
            try self.resourceIds?.forEach {
                try validate($0, name: "resourceIds[]", parent: name, max: 256)
                try validate($0, name: "resourceIds[]", parent: name, min: 1)
            }
            try self.validate(self.resourceIds, name: "resourceIds", parent: name, max: 5)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 256)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceType = "ComplianceType"
            case configRuleNames = "ConfigRuleNames"
            case resourceIds = "ResourceIds"
            case resourceType = "ResourceType"
        }
    }

    public struct ConformancePackEvaluationResult: AWSDecodableShape {
        /// Supplementary information about how the evaluation determined the compliance.
        public let annotation: String?
        /// The compliance type. The allowed values are COMPLIANT and NON_COMPLIANT. INSUFFICIENT_DATA is not supported.
        public let complianceType: ConformancePackComplianceType
        /// The time when Config rule evaluated Amazon Web Services resource.
        public let configRuleInvokedTime: Date
        public let evaluationResultIdentifier: EvaluationResultIdentifier
        /// The time when Config recorded the evaluation result.
        public let resultRecordedTime: Date

        public init(annotation: String? = nil, complianceType: ConformancePackComplianceType, configRuleInvokedTime: Date, evaluationResultIdentifier: EvaluationResultIdentifier, resultRecordedTime: Date) {
            self.annotation = annotation
            self.complianceType = complianceType
            self.configRuleInvokedTime = configRuleInvokedTime
            self.evaluationResultIdentifier = evaluationResultIdentifier
            self.resultRecordedTime = resultRecordedTime
        }

        private enum CodingKeys: String, CodingKey {
            case annotation = "Annotation"
            case complianceType = "ComplianceType"
            case configRuleInvokedTime = "ConfigRuleInvokedTime"
            case evaluationResultIdentifier = "EvaluationResultIdentifier"
            case resultRecordedTime = "ResultRecordedTime"
        }
    }

    public struct ConformancePackInputParameter: AWSEncodableShape & AWSDecodableShape {
        /// One part of a key-value pair.
        public let parameterName: String
        /// Another part of the key-value pair.
        public let parameterValue: String

        public init(parameterName: String, parameterValue: String) {
            self.parameterName = parameterName
            self.parameterValue = parameterValue
        }

        public func validate(name: String) throws {
            try self.validate(self.parameterName, name: "parameterName", parent: name, max: 255)
            try self.validate(self.parameterValue, name: "parameterValue", parent: name, max: 4096)
        }

        private enum CodingKeys: String, CodingKey {
            case parameterName = "ParameterName"
            case parameterValue = "ParameterValue"
        }
    }

    public struct ConformancePackRuleCompliance: AWSDecodableShape {
        /// Compliance of the Config rule.
        /// 		       The allowed values are COMPLIANT, NON_COMPLIANT, and INSUFFICIENT_DATA.
        public let complianceType: ConformancePackComplianceType?
        /// Name of the Config rule.
        public let configRuleName: String?
        /// Controls for the conformance pack. A control is a process to prevent or detect problems while meeting objectives.
        /// 			A control can align with a specific compliance regime or map to internal controls defined by an organization.
        public let controls: [String]?

        public init(complianceType: ConformancePackComplianceType? = nil, configRuleName: String? = nil, controls: [String]? = nil) {
            self.complianceType = complianceType
            self.configRuleName = configRuleName
            self.controls = controls
        }

        private enum CodingKeys: String, CodingKey {
            case complianceType = "ComplianceType"
            case configRuleName = "ConfigRuleName"
            case controls = "Controls"
        }
    }

    public struct ConformancePackStatusDetail: AWSDecodableShape {
        /// Amazon Resource Name (ARN) of comformance pack.
        public let conformancePackArn: String
        /// ID of the conformance pack.
        public let conformancePackId: String
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// Indicates deployment status of conformance pack.
        /// 		       Config sets the state of the conformance pack to:
        /// 		         CREATE_IN_PROGRESS when a conformance pack creation is in progress for an account.   CREATE_COMPLETE when a conformance pack has been successfully created in your account.   CREATE_FAILED when a conformance pack creation failed in your account.   DELETE_IN_PROGRESS when a conformance pack deletion is in progress.    DELETE_FAILED when a conformance pack deletion failed in your account.
        public let conformancePackState: ConformancePackState
        /// The reason of conformance pack creation failure.
        public let conformancePackStatusReason: String?
        /// Last time when conformation pack creation and update was successful.
        public let lastUpdateCompletedTime: Date?
        /// Last time when conformation pack creation and update was requested.
        public let lastUpdateRequestedTime: Date
        /// Amazon Resource Name (ARN) of CloudFormation stack.
        public let stackArn: String

        public init(conformancePackArn: String, conformancePackId: String, conformancePackName: String, conformancePackState: ConformancePackState, conformancePackStatusReason: String? = nil, lastUpdateCompletedTime: Date? = nil, lastUpdateRequestedTime: Date, stackArn: String) {
            self.conformancePackArn = conformancePackArn
            self.conformancePackId = conformancePackId
            self.conformancePackName = conformancePackName
            self.conformancePackState = conformancePackState
            self.conformancePackStatusReason = conformancePackStatusReason
            self.lastUpdateCompletedTime = lastUpdateCompletedTime
            self.lastUpdateRequestedTime = lastUpdateRequestedTime
            self.stackArn = stackArn
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackArn = "ConformancePackArn"
            case conformancePackId = "ConformancePackId"
            case conformancePackName = "ConformancePackName"
            case conformancePackState = "ConformancePackState"
            case conformancePackStatusReason = "ConformancePackStatusReason"
            case lastUpdateCompletedTime = "LastUpdateCompletedTime"
            case lastUpdateRequestedTime = "LastUpdateRequestedTime"
            case stackArn = "StackArn"
        }
    }

    public struct CustomPolicyDetails: AWSEncodableShape & AWSDecodableShape {
        /// The boolean expression for enabling debug logging for your Config Custom Policy rule. The default value is false.
        public let enableDebugLogDelivery: Bool?
        /// The runtime system for your Config Custom Policy rule. Guard is a policy-as-code language that allows you to write policies that are enforced by Config Custom Policy rules. For more information about Guard, see the Guard GitHub
        /// 					Repository.
        public let policyRuntime: String
        /// The policy definition containing the logic for your Config Custom Policy rule.
        public let policyText: String

        public init(enableDebugLogDelivery: Bool? = nil, policyRuntime: String, policyText: String) {
            self.enableDebugLogDelivery = enableDebugLogDelivery
            self.policyRuntime = policyRuntime
            self.policyText = policyText
        }

        public func validate(name: String) throws {
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, max: 64)
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, min: 1)
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, pattern: "^guard\\-2\\.x\\.x$")
            try self.validate(self.policyText, name: "policyText", parent: name, max: 10000)
        }

        private enum CodingKeys: String, CodingKey {
            case enableDebugLogDelivery = "EnableDebugLogDelivery"
            case policyRuntime = "PolicyRuntime"
            case policyText = "PolicyText"
        }
    }

    public struct DeleteAggregationAuthorizationRequest: AWSEncodableShape {
        /// The 12-digit account ID of the account authorized to aggregate
        /// 			data.
        public let authorizedAccountId: String
        /// The region authorized to collect aggregated data.
        public let authorizedAwsRegion: String

        public init(authorizedAccountId: String, authorizedAwsRegion: String) {
            self.authorizedAccountId = authorizedAccountId
            self.authorizedAwsRegion = authorizedAwsRegion
        }

        public func validate(name: String) throws {
            try self.validate(self.authorizedAccountId, name: "authorizedAccountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.authorizedAwsRegion, name: "authorizedAwsRegion", parent: name, max: 64)
            try self.validate(self.authorizedAwsRegion, name: "authorizedAwsRegion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedAccountId = "AuthorizedAccountId"
            case authorizedAwsRegion = "AuthorizedAwsRegion"
        }
    }

    public struct DeleteConfigRuleRequest: AWSEncodableShape {
        /// The name of the Config rule that you want to
        /// 			delete.
        public let configRuleName: String

        public init(configRuleName: String) {
            self.configRuleName = configRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct DeleteConfigurationAggregatorRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String

        public init(configurationAggregatorName: String) {
            self.configurationAggregatorName = configurationAggregatorName
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
        }
    }

    public struct DeleteConfigurationRecorderRequest: AWSEncodableShape {
        /// The name of the configuration recorder to be deleted. You can
        /// 			retrieve the name of your configuration recorder by using the
        /// 				DescribeConfigurationRecorders action.
        public let configurationRecorderName: String

        public init(configurationRecorderName: String) {
            self.configurationRecorderName = configurationRecorderName
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, max: 256)
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorderName = "ConfigurationRecorderName"
        }
    }

    public struct DeleteConformancePackRequest: AWSEncodableShape {
        /// Name of the conformance pack you want to delete.
        public let conformancePackName: String

        public init(conformancePackName: String) {
            self.conformancePackName = conformancePackName
        }

        public func validate(name: String) throws {
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, max: 256)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
        }
    }

    public struct DeleteDeliveryChannelRequest: AWSEncodableShape {
        /// The name of the delivery channel to delete.
        public let deliveryChannelName: String

        public init(deliveryChannelName: String) {
            self.deliveryChannelName = deliveryChannelName
        }

        public func validate(name: String) throws {
            try self.validate(self.deliveryChannelName, name: "deliveryChannelName", parent: name, max: 256)
            try self.validate(self.deliveryChannelName, name: "deliveryChannelName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannelName = "DeliveryChannelName"
        }
    }

    public struct DeleteEvaluationResultsRequest: AWSEncodableShape {
        /// The name of the Config rule for which you want to delete
        /// 			the evaluation results.
        public let configRuleName: String

        public init(configRuleName: String) {
            self.configRuleName = configRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 64)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct DeleteEvaluationResultsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteOrganizationConfigRuleRequest: AWSEncodableShape {
        /// The name of organization Config rule that you want to delete.
        public let organizationConfigRuleName: String

        public init(organizationConfigRuleName: String) {
            self.organizationConfigRuleName = organizationConfigRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, max: 64)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, min: 1)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case organizationConfigRuleName = "OrganizationConfigRuleName"
        }
    }

    public struct DeleteOrganizationConformancePackRequest: AWSEncodableShape {
        /// The name of organization conformance pack that you want to delete.
        public let organizationConformancePackName: String

        public init(organizationConformancePackName: String) {
            self.organizationConformancePackName = organizationConformancePackName
        }

        public func validate(name: String) throws {
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, max: 128)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, min: 1)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case organizationConformancePackName = "OrganizationConformancePackName"
        }
    }

    public struct DeletePendingAggregationRequestRequest: AWSEncodableShape {
        /// The 12-digit account ID of the account requesting to aggregate
        /// 			data.
        public let requesterAccountId: String
        /// The region requesting to aggregate data.
        public let requesterAwsRegion: String

        public init(requesterAccountId: String, requesterAwsRegion: String) {
            self.requesterAccountId = requesterAccountId
            self.requesterAwsRegion = requesterAwsRegion
        }

        public func validate(name: String) throws {
            try self.validate(self.requesterAccountId, name: "requesterAccountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.requesterAwsRegion, name: "requesterAwsRegion", parent: name, max: 64)
            try self.validate(self.requesterAwsRegion, name: "requesterAwsRegion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case requesterAccountId = "RequesterAccountId"
            case requesterAwsRegion = "RequesterAwsRegion"
        }
    }

    public struct DeleteRemediationConfigurationRequest: AWSEncodableShape {
        /// The name of the Config rule for which you want to delete remediation configuration.
        public let configRuleName: String
        /// The type of a resource.
        public let resourceType: String?

        public init(configRuleName: String, resourceType: String? = nil) {
            self.configRuleName = configRuleName
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case resourceType = "ResourceType"
        }
    }

    public struct DeleteRemediationConfigurationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteRemediationExceptionsRequest: AWSEncodableShape {
        /// The name of the Config rule for which you want to delete remediation exception configuration.
        public let configRuleName: String
        /// An exception list of resource exception keys to be processed with the current request. Config adds exception for each resource key. For example, Config adds 3 exceptions for 3 resource keys.
        public let resourceKeys: [RemediationExceptionResourceKey]

        public init(configRuleName: String, resourceKeys: [RemediationExceptionResourceKey]) {
            self.configRuleName = configRuleName
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.resourceKeys.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case resourceKeys = "ResourceKeys"
        }
    }

    public struct DeleteRemediationExceptionsResponse: AWSDecodableShape {
        /// Returns a list of failed delete remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.
        public let failedBatches: [FailedDeleteRemediationExceptionsBatch]?

        public init(failedBatches: [FailedDeleteRemediationExceptionsBatch]? = nil) {
            self.failedBatches = failedBatches
        }

        private enum CodingKeys: String, CodingKey {
            case failedBatches = "FailedBatches"
        }
    }

    public struct DeleteResourceConfigRequest: AWSEncodableShape {
        /// Unique identifier of the resource.
        public let resourceId: String
        /// The type of the resource.
        public let resourceType: String

        public init(resourceId: String, resourceType: String) {
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 196)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct DeleteRetentionConfigurationRequest: AWSEncodableShape {
        /// The name of the retention configuration to delete.
        public let retentionConfigurationName: String

        public init(retentionConfigurationName: String) {
            self.retentionConfigurationName = retentionConfigurationName
        }

        public func validate(name: String) throws {
            try self.validate(self.retentionConfigurationName, name: "retentionConfigurationName", parent: name, max: 256)
            try self.validate(self.retentionConfigurationName, name: "retentionConfigurationName", parent: name, min: 1)
            try self.validate(self.retentionConfigurationName, name: "retentionConfigurationName", parent: name, pattern: "^[\\w\\-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case retentionConfigurationName = "RetentionConfigurationName"
        }
    }

    public struct DeleteStoredQueryRequest: AWSEncodableShape {
        /// The name of the query that you want to delete.
        public let queryName: String

        public init(queryName: String) {
            self.queryName = queryName
        }

        public func validate(name: String) throws {
            try self.validate(self.queryName, name: "queryName", parent: name, max: 64)
            try self.validate(self.queryName, name: "queryName", parent: name, min: 1)
            try self.validate(self.queryName, name: "queryName", parent: name, pattern: "^[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case queryName = "QueryName"
        }
    }

    public struct DeleteStoredQueryResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeliverConfigSnapshotRequest: AWSEncodableShape {
        /// The name of the delivery channel through which the snapshot is
        /// 			delivered.
        public let deliveryChannelName: String

        public init(deliveryChannelName: String) {
            self.deliveryChannelName = deliveryChannelName
        }

        public func validate(name: String) throws {
            try self.validate(self.deliveryChannelName, name: "deliveryChannelName", parent: name, max: 256)
            try self.validate(self.deliveryChannelName, name: "deliveryChannelName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannelName
        }
    }

    public struct DeliverConfigSnapshotResponse: AWSDecodableShape {
        /// The ID of the snapshot that is being created.
        public let configSnapshotId: String?

        public init(configSnapshotId: String? = nil) {
            self.configSnapshotId = configSnapshotId
        }

        private enum CodingKeys: String, CodingKey {
            case configSnapshotId
        }
    }

    public struct DeliveryChannel: AWSEncodableShape & AWSDecodableShape {
        /// The options for how often Config delivers configuration
        /// 			snapshots to the Amazon S3 bucket.
        public let configSnapshotDeliveryProperties: ConfigSnapshotDeliveryProperties?
        /// The name of the delivery channel. By default, Config
        /// 			assigns the name "default" when creating the delivery channel. To
        /// 			change the delivery channel name, you must use the
        /// 			DeleteDeliveryChannel action to delete your current delivery
        /// 			channel, and then you must use the PutDeliveryChannel command to
        /// 			create a delivery channel that has the desired name.
        public let name: String?
        /// The name of the Amazon S3 bucket to which Config delivers
        /// 			configuration snapshots and configuration history files.
        /// 		       If you specify a bucket that belongs to another Amazon Web Services account,
        /// 			that bucket must have policies that grant access permissions to Config. For more information, see Permissions for the Amazon S3 Bucket in the Config
        /// 			Developer Guide.
        public let s3BucketName: String?
        /// The prefix for the specified Amazon S3 bucket.
        public let s3KeyPrefix: String?
        /// The Amazon Resource Name (ARN) of the Key Management Service (KMS ) KMS key (KMS key) used to encrypt objects delivered by Config.
        /// 			Must belong to the same Region as the destination S3 bucket.
        public let s3KmsKeyArn: String?
        /// The Amazon Resource Name (ARN) of the Amazon SNS topic to which
        /// 			Config sends notifications about configuration
        /// 			changes.
        /// 		       If you choose a topic from another account, the topic must have
        /// 			policies that grant access permissions to Config. For more
        /// 			information, see Permissions for the Amazon SNS Topic in the Config
        /// 			Developer Guide.
        public let snsTopicARN: String?

        public init(configSnapshotDeliveryProperties: ConfigSnapshotDeliveryProperties? = nil, name: String? = nil, s3BucketName: String? = nil, s3KeyPrefix: String? = nil, s3KmsKeyArn: String? = nil, snsTopicARN: String? = nil) {
            self.configSnapshotDeliveryProperties = configSnapshotDeliveryProperties
            self.name = name
            self.s3BucketName = s3BucketName
            self.s3KeyPrefix = s3KeyPrefix
            self.s3KmsKeyArn = s3KmsKeyArn
            self.snsTopicARN = snsTopicARN
        }

        public func validate(name: String) throws {
            try self.validate(self.name, name: "name", parent: name, max: 256)
            try self.validate(self.name, name: "name", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configSnapshotDeliveryProperties
            case name
            case s3BucketName
            case s3KeyPrefix
            case s3KmsKeyArn
            case snsTopicARN
        }
    }

    public struct DeliveryChannelStatus: AWSDecodableShape {
        /// A list that contains the status of the delivery of the
        /// 			configuration history to the specified Amazon S3 bucket.
        public let configHistoryDeliveryInfo: ConfigExportDeliveryInfo?
        /// A list containing the status of the delivery of the snapshot to
        /// 			the specified Amazon S3 bucket.
        public let configSnapshotDeliveryInfo: ConfigExportDeliveryInfo?
        /// A list containing the status of the delivery of the
        /// 			configuration stream notification to the specified Amazon SNS
        /// 			topic.
        public let configStreamDeliveryInfo: ConfigStreamDeliveryInfo?
        /// The name of the delivery channel.
        public let name: String?

        public init(configHistoryDeliveryInfo: ConfigExportDeliveryInfo? = nil, configSnapshotDeliveryInfo: ConfigExportDeliveryInfo? = nil, configStreamDeliveryInfo: ConfigStreamDeliveryInfo? = nil, name: String? = nil) {
            self.configHistoryDeliveryInfo = configHistoryDeliveryInfo
            self.configSnapshotDeliveryInfo = configSnapshotDeliveryInfo
            self.configStreamDeliveryInfo = configStreamDeliveryInfo
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case configHistoryDeliveryInfo
            case configSnapshotDeliveryInfo
            case configStreamDeliveryInfo
            case name
        }
    }

    public struct DescribeAggregateComplianceByConfigRulesRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the results by ConfigRuleComplianceFilters object.
        ///
        public let filters: ConfigRuleComplianceFilters?
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is
        /// 			maximum.
        /// 			If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, filters: ConfigRuleComplianceFilters? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 1000)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeAggregateComplianceByConfigRulesResponse: AWSDecodableShape {
        /// Returns a list of AggregateComplianceByConfigRule
        /// 			object.
        public let aggregateComplianceByConfigRules: [AggregateComplianceByConfigRule]?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregateComplianceByConfigRules: [AggregateComplianceByConfigRule]? = nil, nextToken: String? = nil) {
            self.aggregateComplianceByConfigRules = aggregateComplianceByConfigRules
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregateComplianceByConfigRules = "AggregateComplianceByConfigRules"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeAggregateComplianceByConformancePacksRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the result by AggregateConformancePackComplianceFilters object.
        public let filters: AggregateConformancePackComplianceFilters?
        /// The maximum number of conformance packs compliance details returned on each page. The default is maximum. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, filters: AggregateConformancePackComplianceFilters? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeAggregateComplianceByConformancePacksResponse: AWSDecodableShape {
        /// Returns the AggregateComplianceByConformancePack object.
        public let aggregateComplianceByConformancePacks: [AggregateComplianceByConformancePack]?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregateComplianceByConformancePacks: [AggregateComplianceByConformancePack]? = nil, nextToken: String? = nil) {
            self.aggregateComplianceByConformancePacks = aggregateComplianceByConformancePacks
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregateComplianceByConformancePacks = "AggregateComplianceByConformancePacks"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeAggregationAuthorizationsRequest: AWSEncodableShape {
        /// The maximum number of AggregationAuthorizations returned on
        /// 			each page. The default is maximum. If you specify 0, Config uses
        /// 			the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(limit: Int? = nil, nextToken: String? = nil) {
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeAggregationAuthorizationsResponse: AWSDecodableShape {
        /// Returns a list of authorizations granted to various aggregator
        /// 			accounts and regions.
        public let aggregationAuthorizations: [AggregationAuthorization]?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregationAuthorizations: [AggregationAuthorization]? = nil, nextToken: String? = nil) {
            self.aggregationAuthorizations = aggregationAuthorizations
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregationAuthorizations = "AggregationAuthorizations"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeComplianceByConfigRuleRequest: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT and NON_COMPLIANT.
        public let complianceTypes: [ComplianceType]?
        /// Specify one or more Config rule names to filter the results
        /// 			by rule.
        public let configRuleNames: [String]?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?

        public init(complianceTypes: [ComplianceType]? = nil, configRuleNames: [String]? = nil, nextToken: String? = nil) {
            self.complianceTypes = complianceTypes
            self.configRuleNames = configRuleNames
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.complianceTypes, name: "complianceTypes", parent: name, max: 3)
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 128)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
                try validate($0, name: "configRuleNames[]", parent: name, pattern: "\\S")
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceTypes = "ComplianceTypes"
            case configRuleNames = "ConfigRuleNames"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeComplianceByConfigRuleResponse: AWSDecodableShape {
        /// Indicates whether each of the specified Config rules is
        /// 			compliant.
        public let complianceByConfigRules: [ComplianceByConfigRule]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(complianceByConfigRules: [ComplianceByConfigRule]? = nil, nextToken: String? = nil) {
            self.complianceByConfigRules = complianceByConfigRules
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case complianceByConfigRules = "ComplianceByConfigRules"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeComplianceByResourceRequest: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT, NON_COMPLIANT, and INSUFFICIENT_DATA.
        public let complianceTypes: [ComplianceType]?
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is 10. You cannot specify a number greater than 100. If
        /// 			you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// The ID of the Amazon Web Services resource for which you want compliance
        /// 			information. You can specify only one resource ID. If you specify a
        /// 			resource ID, you must also specify a type for
        /// 				ResourceType.
        public let resourceId: String?
        /// The types of Amazon Web Services resources for which you want compliance
        /// 			information (for example, AWS::EC2::Instance). For this
        /// 			action, you can specify that the resource type is an Amazon Web Services account by
        /// 			specifying AWS::::Account.
        public let resourceType: String?

        public init(complianceTypes: [ComplianceType]? = nil, limit: Int? = nil, nextToken: String? = nil, resourceId: String? = nil, resourceType: String? = nil) {
            self.complianceTypes = complianceTypes
            self.limit = limit
            self.nextToken = nextToken
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.complianceTypes, name: "complianceTypes", parent: name, max: 3)
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 256)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceTypes = "ComplianceTypes"
            case limit = "Limit"
            case nextToken = "NextToken"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct DescribeComplianceByResourceResponse: AWSDecodableShape {
        /// Indicates whether the specified Amazon Web Services resource complies with all
        /// 			of the Config rules that evaluate it.
        public let complianceByResources: [ComplianceByResource]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(complianceByResources: [ComplianceByResource]? = nil, nextToken: String? = nil) {
            self.complianceByResources = complianceByResources
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case complianceByResources = "ComplianceByResources"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigRuleEvaluationStatusRequest: AWSEncodableShape {
        /// The name of the Config managed rules for which you want
        /// 			status information. If you do not specify any names, Config
        /// 			returns status information for all Config managed rules that you
        /// 			use.
        public let configRuleNames: [String]?
        /// The number of rule evaluation results that you want
        /// 			returned.
        ///
        /// 		       This parameter is required if the rule limit for your account
        /// 			is more than the default of 150 rules.
        /// 		       For information about requesting a rule limit increase, see
        /// 				Config Limits in the Amazon Web Services General
        /// 				Reference Guide.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?

        public init(configRuleNames: [String]? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configRuleNames = configRuleNames
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 128)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
                try validate($0, name: "configRuleNames[]", parent: name, pattern: "\\S")
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 25)
            try self.validate(self.limit, name: "limit", parent: name, max: 50)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleNames = "ConfigRuleNames"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigRuleEvaluationStatusResponse: AWSDecodableShape {
        /// Status information about your Config managed rules.
        public let configRulesEvaluationStatus: [ConfigRuleEvaluationStatus]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(configRulesEvaluationStatus: [ConfigRuleEvaluationStatus]? = nil, nextToken: String? = nil) {
            self.configRulesEvaluationStatus = configRulesEvaluationStatus
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case configRulesEvaluationStatus = "ConfigRulesEvaluationStatus"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigRulesFilters: AWSEncodableShape {
        /// The mode of an evaluation. The valid values are Detective or Proactive.
        public let evaluationMode: EvaluationMode?

        public init(evaluationMode: EvaluationMode? = nil) {
            self.evaluationMode = evaluationMode
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationMode = "EvaluationMode"
        }
    }

    public struct DescribeConfigRulesRequest: AWSEncodableShape {
        /// The names of the Config rules for which you want details.
        /// 			If you do not specify any names, Config returns details for all
        /// 			your rules.
        public let configRuleNames: [String]?
        /// Returns a list of Detecive or Proactive Config rules. By default, this API returns an unfiltered list.
        public let filters: DescribeConfigRulesFilters?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?

        public init(configRuleNames: [String]? = nil, filters: DescribeConfigRulesFilters? = nil, nextToken: String? = nil) {
            self.configRuleNames = configRuleNames
            self.filters = filters
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 128)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
                try validate($0, name: "configRuleNames[]", parent: name, pattern: "\\S")
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleNames = "ConfigRuleNames"
            case filters = "Filters"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigRulesResponse: AWSDecodableShape {
        /// The details about your Config rules.
        public let configRules: [ConfigRule]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(configRules: [ConfigRule]? = nil, nextToken: String? = nil) {
            self.configRules = configRules
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case configRules = "ConfigRules"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigurationAggregatorSourcesStatusRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// The maximum number of AggregatorSourceStatus returned on each
        /// 			page. The default is maximum. If you specify 0, Config uses the
        /// 			default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Filters the status type.
        ///
        /// 				           Valid value FAILED indicates errors while moving
        /// 					data.
        ///
        /// 				           Valid value SUCCEEDED indicates the data was
        /// 					successfully moved.
        ///
        /// 				           Valid value OUTDATED indicates the data is not the most
        /// 					recent.
        ///
        public let updateStatus: [AggregatedSourceStatusType]?

        public init(configurationAggregatorName: String, limit: Int? = nil, nextToken: String? = nil, updateStatus: [AggregatedSourceStatusType]? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.limit = limit
            self.nextToken = nextToken
            self.updateStatus = updateStatus
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.updateStatus, name: "updateStatus", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case limit = "Limit"
            case nextToken = "NextToken"
            case updateStatus = "UpdateStatus"
        }
    }

    public struct DescribeConfigurationAggregatorSourcesStatusResponse: AWSDecodableShape {
        /// Returns an AggregatedSourceStatus object.
        ///
        public let aggregatedSourceStatusList: [AggregatedSourceStatus]?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregatedSourceStatusList: [AggregatedSourceStatus]? = nil, nextToken: String? = nil) {
            self.aggregatedSourceStatusList = aggregatedSourceStatusList
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregatedSourceStatusList = "AggregatedSourceStatusList"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigurationAggregatorsRequest: AWSEncodableShape {
        /// The name of the configuration aggregators.
        public let configurationAggregatorNames: [String]?
        /// The maximum number of configuration aggregators returned on
        /// 			each page. The default is maximum. If you specify 0, Config uses
        /// 			the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorNames: [String]? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorNames = configurationAggregatorNames
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.configurationAggregatorNames?.forEach {
                try validate($0, name: "configurationAggregatorNames[]", parent: name, max: 256)
                try validate($0, name: "configurationAggregatorNames[]", parent: name, min: 1)
                try validate($0, name: "configurationAggregatorNames[]", parent: name, pattern: "^[\\w\\-]+$")
            }
            try self.validate(self.configurationAggregatorNames, name: "configurationAggregatorNames", parent: name, max: 10)
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorNames = "ConfigurationAggregatorNames"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigurationAggregatorsResponse: AWSDecodableShape {
        /// Returns a ConfigurationAggregators object.
        public let configurationAggregators: [ConfigurationAggregator]?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregators: [ConfigurationAggregator]? = nil, nextToken: String? = nil) {
            self.configurationAggregators = configurationAggregators
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregators = "ConfigurationAggregators"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConfigurationRecorderStatusRequest: AWSEncodableShape {
        /// The name(s) of the configuration recorder. If the name is not
        /// 			specified, the action returns the current status of all the
        /// 			configuration recorders associated with the account.
        public let configurationRecorderNames: [String]?

        public init(configurationRecorderNames: [String]? = nil) {
            self.configurationRecorderNames = configurationRecorderNames
        }

        public func validate(name: String) throws {
            try self.configurationRecorderNames?.forEach {
                try validate($0, name: "configurationRecorderNames[]", parent: name, max: 256)
                try validate($0, name: "configurationRecorderNames[]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorderNames = "ConfigurationRecorderNames"
        }
    }

    public struct DescribeConfigurationRecorderStatusResponse: AWSDecodableShape {
        /// A list that contains status of the specified
        /// 			recorders.
        public let configurationRecordersStatus: [ConfigurationRecorderStatus]?

        public init(configurationRecordersStatus: [ConfigurationRecorderStatus]? = nil) {
            self.configurationRecordersStatus = configurationRecordersStatus
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecordersStatus = "ConfigurationRecordersStatus"
        }
    }

    public struct DescribeConfigurationRecordersRequest: AWSEncodableShape {
        /// A list of configuration recorder names.
        public let configurationRecorderNames: [String]?

        public init(configurationRecorderNames: [String]? = nil) {
            self.configurationRecorderNames = configurationRecorderNames
        }

        public func validate(name: String) throws {
            try self.configurationRecorderNames?.forEach {
                try validate($0, name: "configurationRecorderNames[]", parent: name, max: 256)
                try validate($0, name: "configurationRecorderNames[]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorderNames = "ConfigurationRecorderNames"
        }
    }

    public struct DescribeConfigurationRecordersResponse: AWSDecodableShape {
        /// A list that contains the descriptions of the specified
        /// 			configuration recorders.
        public let configurationRecorders: [ConfigurationRecorder]?

        public init(configurationRecorders: [ConfigurationRecorder]? = nil) {
            self.configurationRecorders = configurationRecorders
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorders = "ConfigurationRecorders"
        }
    }

    public struct DescribeConformancePackComplianceRequest: AWSEncodableShape {
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// A ConformancePackComplianceFilters object.
        public let filters: ConformancePackComplianceFilters?
        /// The maximum number of Config rules within a conformance pack are returned on each page.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackName: String, filters: ConformancePackComplianceFilters? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.conformancePackName = conformancePackName
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, max: 256)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 1000)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConformancePackComplianceResponse: AWSDecodableShape {
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// Returns a list of ConformancePackRuleCompliance objects.
        public let conformancePackRuleComplianceList: [ConformancePackRuleCompliance]
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackName: String, conformancePackRuleComplianceList: [ConformancePackRuleCompliance], nextToken: String? = nil) {
            self.conformancePackName = conformancePackName
            self.conformancePackRuleComplianceList = conformancePackRuleComplianceList
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
            case conformancePackRuleComplianceList = "ConformancePackRuleComplianceList"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConformancePackStatusRequest: AWSEncodableShape {
        /// Comma-separated list of conformance pack names.
        public let conformancePackNames: [String]?
        /// The maximum number of conformance packs status returned on each page.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackNames: [String]? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.conformancePackNames = conformancePackNames
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.conformancePackNames?.forEach {
                try validate($0, name: "conformancePackNames[]", parent: name, max: 256)
                try validate($0, name: "conformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "conformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, max: 25)
            try self.validate(self.limit, name: "limit", parent: name, max: 20)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackNames = "ConformancePackNames"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConformancePackStatusResponse: AWSDecodableShape {
        /// A list of ConformancePackStatusDetail objects.
        public let conformancePackStatusDetails: [ConformancePackStatusDetail]?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackStatusDetails: [ConformancePackStatusDetail]? = nil, nextToken: String? = nil) {
            self.conformancePackStatusDetails = conformancePackStatusDetails
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackStatusDetails = "ConformancePackStatusDetails"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConformancePacksRequest: AWSEncodableShape {
        /// Comma-separated list of conformance pack names for which you want details. If you do not specify any names, Config returns details for all your conformance packs.
        public let conformancePackNames: [String]?
        /// The maximum number of conformance packs returned on each page.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackNames: [String]? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.conformancePackNames = conformancePackNames
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.conformancePackNames?.forEach {
                try validate($0, name: "conformancePackNames[]", parent: name, max: 256)
                try validate($0, name: "conformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "conformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, max: 25)
            try self.validate(self.limit, name: "limit", parent: name, max: 20)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackNames = "ConformancePackNames"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeConformancePacksResponse: AWSDecodableShape {
        /// Returns a list of ConformancePackDetail objects.
        public let conformancePackDetails: [ConformancePackDetail]?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackDetails: [ConformancePackDetail]? = nil, nextToken: String? = nil) {
            self.conformancePackDetails = conformancePackDetails
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackDetails = "ConformancePackDetails"
            case nextToken = "NextToken"
        }
    }

    public struct DescribeDeliveryChannelStatusRequest: AWSEncodableShape {
        /// A list of delivery channel names.
        public let deliveryChannelNames: [String]?

        public init(deliveryChannelNames: [String]? = nil) {
            self.deliveryChannelNames = deliveryChannelNames
        }

        public func validate(name: String) throws {
            try self.deliveryChannelNames?.forEach {
                try validate($0, name: "deliveryChannelNames[]", parent: name, max: 256)
                try validate($0, name: "deliveryChannelNames[]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannelNames = "DeliveryChannelNames"
        }
    }

    public struct DescribeDeliveryChannelStatusResponse: AWSDecodableShape {
        /// A list that contains the status of a specified delivery
        /// 			channel.
        public let deliveryChannelsStatus: [DeliveryChannelStatus]?

        public init(deliveryChannelsStatus: [DeliveryChannelStatus]? = nil) {
            self.deliveryChannelsStatus = deliveryChannelsStatus
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannelsStatus = "DeliveryChannelsStatus"
        }
    }

    public struct DescribeDeliveryChannelsRequest: AWSEncodableShape {
        /// A list of delivery channel names.
        public let deliveryChannelNames: [String]?

        public init(deliveryChannelNames: [String]? = nil) {
            self.deliveryChannelNames = deliveryChannelNames
        }

        public func validate(name: String) throws {
            try self.deliveryChannelNames?.forEach {
                try validate($0, name: "deliveryChannelNames[]", parent: name, max: 256)
                try validate($0, name: "deliveryChannelNames[]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannelNames = "DeliveryChannelNames"
        }
    }

    public struct DescribeDeliveryChannelsResponse: AWSDecodableShape {
        /// A list that contains the descriptions of the specified delivery
        /// 			channel.
        public let deliveryChannels: [DeliveryChannel]?

        public init(deliveryChannels: [DeliveryChannel]? = nil) {
            self.deliveryChannels = deliveryChannels
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannels = "DeliveryChannels"
        }
    }

    public struct DescribeOrganizationConfigRuleStatusesRequest: AWSEncodableShape {
        /// The maximum number of OrganizationConfigRuleStatuses returned on each page. If you do no specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The names of organization Config rules for which you want status details. If you do not specify any names, Config returns details for all your organization Config rules.
        public let organizationConfigRuleNames: [String]?

        public init(limit: Int? = nil, nextToken: String? = nil, organizationConfigRuleNames: [String]? = nil) {
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConfigRuleNames = organizationConfigRuleNames
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.organizationConfigRuleNames?.forEach {
                try validate($0, name: "organizationConfigRuleNames[]", parent: name, max: 64)
                try validate($0, name: "organizationConfigRuleNames[]", parent: name, min: 1)
            }
            try self.validate(self.organizationConfigRuleNames, name: "organizationConfigRuleNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConfigRuleNames = "OrganizationConfigRuleNames"
        }
    }

    public struct DescribeOrganizationConfigRuleStatusesResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// A list of OrganizationConfigRuleStatus objects.
        public let organizationConfigRuleStatuses: [OrganizationConfigRuleStatus]?

        public init(nextToken: String? = nil, organizationConfigRuleStatuses: [OrganizationConfigRuleStatus]? = nil) {
            self.nextToken = nextToken
            self.organizationConfigRuleStatuses = organizationConfigRuleStatuses
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConfigRuleStatuses = "OrganizationConfigRuleStatuses"
        }
    }

    public struct DescribeOrganizationConfigRulesRequest: AWSEncodableShape {
        /// The maximum number of organization Config rules returned on each page. If you do no specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The names of organization Config rules for which you want details. If you do not specify any names, Config returns details for all your organization Config rules.
        public let organizationConfigRuleNames: [String]?

        public init(limit: Int? = nil, nextToken: String? = nil, organizationConfigRuleNames: [String]? = nil) {
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConfigRuleNames = organizationConfigRuleNames
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.organizationConfigRuleNames?.forEach {
                try validate($0, name: "organizationConfigRuleNames[]", parent: name, max: 64)
                try validate($0, name: "organizationConfigRuleNames[]", parent: name, min: 1)
            }
            try self.validate(self.organizationConfigRuleNames, name: "organizationConfigRuleNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConfigRuleNames = "OrganizationConfigRuleNames"
        }
    }

    public struct DescribeOrganizationConfigRulesResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a list of OrganizationConfigRule objects.
        public let organizationConfigRules: [OrganizationConfigRule]?

        public init(nextToken: String? = nil, organizationConfigRules: [OrganizationConfigRule]? = nil) {
            self.nextToken = nextToken
            self.organizationConfigRules = organizationConfigRules
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConfigRules = "OrganizationConfigRules"
        }
    }

    public struct DescribeOrganizationConformancePackStatusesRequest: AWSEncodableShape {
        /// The maximum number of OrganizationConformancePackStatuses returned on each page.
        /// 			If you do no specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The names of organization conformance packs for which you want status details.
        /// 			If you do not specify any names, Config returns details for all your organization conformance packs.
        public let organizationConformancePackNames: [String]?

        public init(limit: Int? = nil, nextToken: String? = nil, organizationConformancePackNames: [String]? = nil) {
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConformancePackNames = organizationConformancePackNames
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.organizationConformancePackNames?.forEach {
                try validate($0, name: "organizationConformancePackNames[]", parent: name, max: 128)
                try validate($0, name: "organizationConformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "organizationConformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.organizationConformancePackNames, name: "organizationConformancePackNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConformancePackNames = "OrganizationConformancePackNames"
        }
    }

    public struct DescribeOrganizationConformancePackStatusesResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// A list of OrganizationConformancePackStatus objects.
        public let organizationConformancePackStatuses: [OrganizationConformancePackStatus]?

        public init(nextToken: String? = nil, organizationConformancePackStatuses: [OrganizationConformancePackStatus]? = nil) {
            self.nextToken = nextToken
            self.organizationConformancePackStatuses = organizationConformancePackStatuses
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConformancePackStatuses = "OrganizationConformancePackStatuses"
        }
    }

    public struct DescribeOrganizationConformancePacksRequest: AWSEncodableShape {
        /// The maximum number of organization config packs returned on each page. If you do no specify a
        /// 			number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a
        /// 			paginated response.
        public let nextToken: String?
        /// The name that you assign to an organization conformance pack.
        public let organizationConformancePackNames: [String]?

        public init(limit: Int? = nil, nextToken: String? = nil, organizationConformancePackNames: [String]? = nil) {
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConformancePackNames = organizationConformancePackNames
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.organizationConformancePackNames?.forEach {
                try validate($0, name: "organizationConformancePackNames[]", parent: name, max: 128)
                try validate($0, name: "organizationConformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "organizationConformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.organizationConformancePackNames, name: "organizationConformancePackNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConformancePackNames = "OrganizationConformancePackNames"
        }
    }

    public struct DescribeOrganizationConformancePacksResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a
        /// 			paginated response.
        public let nextToken: String?
        /// Returns a list of OrganizationConformancePacks objects.
        public let organizationConformancePacks: [OrganizationConformancePack]?

        public init(nextToken: String? = nil, organizationConformancePacks: [OrganizationConformancePack]? = nil) {
            self.nextToken = nextToken
            self.organizationConformancePacks = organizationConformancePacks
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConformancePacks = "OrganizationConformancePacks"
        }
    }

    public struct DescribePendingAggregationRequestsRequest: AWSEncodableShape {
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is maximum. If you specify 0, Config uses the
        /// 			default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(limit: Int? = nil, nextToken: String? = nil) {
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 20)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct DescribePendingAggregationRequestsResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a PendingAggregationRequests object.
        public let pendingAggregationRequests: [PendingAggregationRequest]?

        public init(nextToken: String? = nil, pendingAggregationRequests: [PendingAggregationRequest]? = nil) {
            self.nextToken = nextToken
            self.pendingAggregationRequests = pendingAggregationRequests
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case pendingAggregationRequests = "PendingAggregationRequests"
        }
    }

    public struct DescribeRemediationConfigurationsRequest: AWSEncodableShape {
        /// A list of Config rule names of remediation configurations for which you want details.
        public let configRuleNames: [String]

        public init(configRuleNames: [String]) {
            self.configRuleNames = configRuleNames
        }

        public func validate(name: String) throws {
            try self.configRuleNames.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 128)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
                try validate($0, name: "configRuleNames[]", parent: name, pattern: "\\S")
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleNames = "ConfigRuleNames"
        }
    }

    public struct DescribeRemediationConfigurationsResponse: AWSDecodableShape {
        /// Returns a remediation configuration object.
        public let remediationConfigurations: [RemediationConfiguration]?

        public init(remediationConfigurations: [RemediationConfiguration]? = nil) {
            self.remediationConfigurations = remediationConfigurations
        }

        private enum CodingKeys: String, CodingKey {
            case remediationConfigurations = "RemediationConfigurations"
        }
    }

    public struct DescribeRemediationExceptionsRequest: AWSEncodableShape {
        /// The name of the Config rule.
        public let configRuleName: String
        /// The maximum number of RemediationExceptionResourceKey returned on each page. The default is 25. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?
        /// An exception list of resource exception keys to be processed with the current request. Config adds exception for each resource key. For example, Config adds 3 exceptions for 3 resource keys.
        public let resourceKeys: [RemediationExceptionResourceKey]?

        public init(configRuleName: String, limit: Int? = nil, nextToken: String? = nil, resourceKeys: [RemediationExceptionResourceKey]? = nil) {
            self.configRuleName = configRuleName
            self.limit = limit
            self.nextToken = nextToken
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.resourceKeys?.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case limit = "Limit"
            case nextToken = "NextToken"
            case resourceKeys = "ResourceKeys"
        }
    }

    public struct DescribeRemediationExceptionsResponse: AWSDecodableShape {
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a list of remediation exception objects.
        public let remediationExceptions: [RemediationException]?

        public init(nextToken: String? = nil, remediationExceptions: [RemediationException]? = nil) {
            self.nextToken = nextToken
            self.remediationExceptions = remediationExceptions
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case remediationExceptions = "RemediationExceptions"
        }
    }

    public struct DescribeRemediationExecutionStatusRequest: AWSEncodableShape {
        /// A list of Config rule names.
        public let configRuleName: String
        /// The maximum number of RemediationExecutionStatuses returned on each page. The default is maximum. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// A list of resource keys to be processed with the current request. Each element in the list consists of the resource type and resource ID.
        public let resourceKeys: [ResourceKey]?

        public init(configRuleName: String, limit: Int? = nil, nextToken: String? = nil, resourceKeys: [ResourceKey]? = nil) {
            self.configRuleName = configRuleName
            self.limit = limit
            self.nextToken = nextToken
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.resourceKeys?.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case limit = "Limit"
            case nextToken = "NextToken"
            case resourceKeys = "ResourceKeys"
        }
    }

    public struct DescribeRemediationExecutionStatusResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a list of remediation execution statuses objects.
        public let remediationExecutionStatuses: [RemediationExecutionStatus]?

        public init(nextToken: String? = nil, remediationExecutionStatuses: [RemediationExecutionStatus]? = nil) {
            self.nextToken = nextToken
            self.remediationExecutionStatuses = remediationExecutionStatuses
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case remediationExecutionStatuses = "RemediationExecutionStatuses"
        }
    }

    public struct DescribeRetentionConfigurationsRequest: AWSEncodableShape {
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// A list of names of retention configurations for which you want
        /// 			details. If you do not specify a name, Config returns details
        /// 			for all the retention configurations for that account.
        ///
        /// 			         Currently, Config supports only one retention
        /// 				configuration per region in your account.
        ///
        public let retentionConfigurationNames: [String]?

        public init(nextToken: String? = nil, retentionConfigurationNames: [String]? = nil) {
            self.nextToken = nextToken
            self.retentionConfigurationNames = retentionConfigurationNames
        }

        public func validate(name: String) throws {
            try self.retentionConfigurationNames?.forEach {
                try validate($0, name: "retentionConfigurationNames[]", parent: name, max: 256)
                try validate($0, name: "retentionConfigurationNames[]", parent: name, min: 1)
                try validate($0, name: "retentionConfigurationNames[]", parent: name, pattern: "^[\\w\\-]+$")
            }
            try self.validate(self.retentionConfigurationNames, name: "retentionConfigurationNames", parent: name, max: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case retentionConfigurationNames = "RetentionConfigurationNames"
        }
    }

    public struct DescribeRetentionConfigurationsResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// Returns a retention configuration object.
        public let retentionConfigurations: [RetentionConfiguration]?

        public init(nextToken: String? = nil, retentionConfigurations: [RetentionConfiguration]? = nil) {
            self.nextToken = nextToken
            self.retentionConfigurations = retentionConfigurations
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case retentionConfigurations = "RetentionConfigurations"
        }
    }

    public struct Evaluation: AWSEncodableShape & AWSDecodableShape {
        /// Supplementary information about how the evaluation determined
        /// 			the compliance.
        public let annotation: String?
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let complianceResourceId: String
        /// The type of Amazon Web Services resource that was evaluated.
        public let complianceResourceType: String
        /// Indicates whether the Amazon Web Services resource complies with the Config
        /// 			rule that it was evaluated against.
        /// 		       For the Evaluation data type, Config supports
        /// 			only the COMPLIANT, NON_COMPLIANT, and
        /// 				NOT_APPLICABLE values. Config does not support
        /// 			the INSUFFICIENT_DATA value for this data
        /// 			type.
        /// 		       Similarly, Config does not accept
        /// 				INSUFFICIENT_DATA as the value for
        /// 				ComplianceType from a PutEvaluations
        /// 			request. For example, an Lambda function for a custom Config
        /// 			rule cannot pass an INSUFFICIENT_DATA value to Config.
        public let complianceType: ComplianceType
        /// The time of the event in Config that triggered the
        /// 			evaluation. For event-based evaluations, the time indicates when Config created the configuration item that triggered the evaluation.
        /// 			For periodic evaluations, the time indicates when Config
        /// 			triggered the evaluation at the frequency that you specified (for
        /// 			example, every 24 hours).
        public let orderingTimestamp: Date

        public init(annotation: String? = nil, complianceResourceId: String, complianceResourceType: String, complianceType: ComplianceType, orderingTimestamp: Date) {
            self.annotation = annotation
            self.complianceResourceId = complianceResourceId
            self.complianceResourceType = complianceResourceType
            self.complianceType = complianceType
            self.orderingTimestamp = orderingTimestamp
        }

        public func validate(name: String) throws {
            try self.validate(self.annotation, name: "annotation", parent: name, max: 256)
            try self.validate(self.annotation, name: "annotation", parent: name, min: 1)
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, max: 768)
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, min: 1)
            try self.validate(self.complianceResourceType, name: "complianceResourceType", parent: name, max: 256)
            try self.validate(self.complianceResourceType, name: "complianceResourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case annotation = "Annotation"
            case complianceResourceId = "ComplianceResourceId"
            case complianceResourceType = "ComplianceResourceType"
            case complianceType = "ComplianceType"
            case orderingTimestamp = "OrderingTimestamp"
        }
    }

    public struct EvaluationContext: AWSEncodableShape & AWSDecodableShape {
        /// A unique EvaluationContextIdentifier ID for an EvaluationContext.
        public let evaluationContextIdentifier: String?

        public init(evaluationContextIdentifier: String? = nil) {
            self.evaluationContextIdentifier = evaluationContextIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.evaluationContextIdentifier, name: "evaluationContextIdentifier", parent: name, max: 128)
            try self.validate(self.evaluationContextIdentifier, name: "evaluationContextIdentifier", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationContextIdentifier = "EvaluationContextIdentifier"
        }
    }

    public struct EvaluationModeConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The mode of an evaluation. The valid values are Detective or Proactive.
        public let mode: EvaluationMode?

        public init(mode: EvaluationMode? = nil) {
            self.mode = mode
        }

        private enum CodingKeys: String, CodingKey {
            case mode = "Mode"
        }
    }

    public struct EvaluationResult: AWSDecodableShape {
        /// Supplementary information about how the evaluation determined
        /// 			the compliance.
        public let annotation: String?
        /// Indicates whether the Amazon Web Services resource complies with the Config
        /// 			rule that evaluated it.
        /// 		       For the EvaluationResult data type, Config
        /// 			supports only the COMPLIANT,
        /// 			NON_COMPLIANT, and NOT_APPLICABLE values.
        /// 			Config does not support the INSUFFICIENT_DATA value
        /// 			for the EvaluationResult data type.
        public let complianceType: ComplianceType?
        /// The time when the Config rule evaluated the Amazon Web Services
        /// 			resource.
        public let configRuleInvokedTime: Date?
        /// Uniquely identifies the evaluation result.
        public let evaluationResultIdentifier: EvaluationResultIdentifier?
        /// The time when Config recorded the evaluation
        /// 			result.
        public let resultRecordedTime: Date?
        /// An encrypted token that associates an evaluation with an Config rule. The token identifies the rule, the Amazon Web Services resource being
        /// 			evaluated, and the event that triggered the evaluation.
        public let resultToken: String?

        public init(annotation: String? = nil, complianceType: ComplianceType? = nil, configRuleInvokedTime: Date? = nil, evaluationResultIdentifier: EvaluationResultIdentifier? = nil, resultRecordedTime: Date? = nil, resultToken: String? = nil) {
            self.annotation = annotation
            self.complianceType = complianceType
            self.configRuleInvokedTime = configRuleInvokedTime
            self.evaluationResultIdentifier = evaluationResultIdentifier
            self.resultRecordedTime = resultRecordedTime
            self.resultToken = resultToken
        }

        private enum CodingKeys: String, CodingKey {
            case annotation = "Annotation"
            case complianceType = "ComplianceType"
            case configRuleInvokedTime = "ConfigRuleInvokedTime"
            case evaluationResultIdentifier = "EvaluationResultIdentifier"
            case resultRecordedTime = "ResultRecordedTime"
            case resultToken = "ResultToken"
        }
    }

    public struct EvaluationResultIdentifier: AWSDecodableShape {
        /// Identifies an Config rule used to evaluate an Amazon Web Services resource,
        /// 			and provides the type and ID of the evaluated resource.
        public let evaluationResultQualifier: EvaluationResultQualifier?
        /// The time of the event that triggered the evaluation of your Amazon Web Services
        /// 			resources. The time can indicate when Config delivered a
        /// 			configuration item change notification, or it can indicate when Config delivered the configuration snapshot, depending on which
        /// 			event triggered the evaluation.
        public let orderingTimestamp: Date?
        /// A Unique ID for an evaluation result.
        public let resourceEvaluationId: String?

        public init(evaluationResultQualifier: EvaluationResultQualifier? = nil, orderingTimestamp: Date? = nil, resourceEvaluationId: String? = nil) {
            self.evaluationResultQualifier = evaluationResultQualifier
            self.orderingTimestamp = orderingTimestamp
            self.resourceEvaluationId = resourceEvaluationId
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationResultQualifier = "EvaluationResultQualifier"
            case orderingTimestamp = "OrderingTimestamp"
            case resourceEvaluationId = "ResourceEvaluationId"
        }
    }

    public struct EvaluationResultQualifier: AWSDecodableShape {
        /// The name of the Config rule that was used in the
        /// 			evaluation.
        public let configRuleName: String?
        /// The mode of an evaluation. The valid values are Detective or Proactive.
        public let evaluationMode: EvaluationMode?
        /// The ID of the evaluated Amazon Web Services resource.
        public let resourceId: String?
        /// The type of Amazon Web Services resource that was evaluated.
        public let resourceType: String?

        public init(configRuleName: String? = nil, evaluationMode: EvaluationMode? = nil, resourceId: String? = nil, resourceType: String? = nil) {
            self.configRuleName = configRuleName
            self.evaluationMode = evaluationMode
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case evaluationMode = "EvaluationMode"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct EvaluationStatus: AWSDecodableShape {
        /// An explanation for failed execution status.
        public let failureReason: String?
        /// The status of an execution. The valid values are In_Progress, Succeeded or Failed.
        public let status: ResourceEvaluationStatus

        public init(failureReason: String? = nil, status: ResourceEvaluationStatus) {
            self.failureReason = failureReason
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case failureReason = "FailureReason"
            case status = "Status"
        }
    }

    public struct ExecutionControls: AWSEncodableShape & AWSDecodableShape {
        /// A SsmControls object.
        public let ssmControls: SsmControls?

        public init(ssmControls: SsmControls? = nil) {
            self.ssmControls = ssmControls
        }

        public func validate(name: String) throws {
            try self.ssmControls?.validate(name: "\(name).ssmControls")
        }

        private enum CodingKeys: String, CodingKey {
            case ssmControls = "SsmControls"
        }
    }

    public struct ExternalEvaluation: AWSEncodableShape {
        /// Supplementary information about the reason of compliance. For example, this task was completed on a specific date.
        public let annotation: String?
        /// The evaluated compliance resource ID. Config accepts only Amazon Web Services account ID.
        public let complianceResourceId: String
        /// The evaluated compliance resource type. Config accepts AWS::::Account resource type.
        public let complianceResourceType: String
        /// The compliance of the Amazon Web Services resource. The valid values are COMPLIANT, NON_COMPLIANT,  and NOT_APPLICABLE.
        public let complianceType: ComplianceType
        /// The time when the compliance was recorded.
        public let orderingTimestamp: Date

        public init(annotation: String? = nil, complianceResourceId: String, complianceResourceType: String, complianceType: ComplianceType, orderingTimestamp: Date) {
            self.annotation = annotation
            self.complianceResourceId = complianceResourceId
            self.complianceResourceType = complianceResourceType
            self.complianceType = complianceType
            self.orderingTimestamp = orderingTimestamp
        }

        public func validate(name: String) throws {
            try self.validate(self.annotation, name: "annotation", parent: name, max: 256)
            try self.validate(self.annotation, name: "annotation", parent: name, min: 1)
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, max: 768)
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, min: 1)
            try self.validate(self.complianceResourceType, name: "complianceResourceType", parent: name, max: 256)
            try self.validate(self.complianceResourceType, name: "complianceResourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case annotation = "Annotation"
            case complianceResourceId = "ComplianceResourceId"
            case complianceResourceType = "ComplianceResourceType"
            case complianceType = "ComplianceType"
            case orderingTimestamp = "OrderingTimestamp"
        }
    }

    public struct FailedDeleteRemediationExceptionsBatch: AWSDecodableShape {
        /// Returns remediation exception resource key object of the failed items.
        public let failedItems: [RemediationExceptionResourceKey]?
        /// Returns a failure message for delete remediation exception. For example, Config creates an exception due to an internal error.
        public let failureMessage: String?

        public init(failedItems: [RemediationExceptionResourceKey]? = nil, failureMessage: String? = nil) {
            self.failedItems = failedItems
            self.failureMessage = failureMessage
        }

        private enum CodingKeys: String, CodingKey {
            case failedItems = "FailedItems"
            case failureMessage = "FailureMessage"
        }
    }

    public struct FailedRemediationBatch: AWSDecodableShape {
        /// Returns remediation configurations of the failed items.
        public let failedItems: [RemediationConfiguration]?
        /// Returns a failure message. For example, the resource is already compliant.
        public let failureMessage: String?

        public init(failedItems: [RemediationConfiguration]? = nil, failureMessage: String? = nil) {
            self.failedItems = failedItems
            self.failureMessage = failureMessage
        }

        private enum CodingKeys: String, CodingKey {
            case failedItems = "FailedItems"
            case failureMessage = "FailureMessage"
        }
    }

    public struct FailedRemediationExceptionBatch: AWSDecodableShape {
        /// Returns remediation exception resource key object of the failed items.
        public let failedItems: [RemediationException]?
        /// Returns a failure message. For example, the auto-remediation has failed.
        public let failureMessage: String?

        public init(failedItems: [RemediationException]? = nil, failureMessage: String? = nil) {
            self.failedItems = failedItems
            self.failureMessage = failureMessage
        }

        private enum CodingKeys: String, CodingKey {
            case failedItems = "FailedItems"
            case failureMessage = "FailureMessage"
        }
    }

    public struct FieldInfo: AWSDecodableShape {
        /// Name of the field.
        public let name: String?

        public init(name: String? = nil) {
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
        }
    }

    public struct GetAggregateComplianceDetailsByConfigRuleRequest: AWSEncodableShape {
        /// The 12-digit account ID of the source account.
        public let accountId: String
        /// The source region from where the data is aggregated.
        public let awsRegion: String
        /// The resource compliance status.
        ///
        /// 			         For the
        /// 					GetAggregateComplianceDetailsByConfigRuleRequest
        /// 				data type, Config supports only the COMPLIANT
        /// 				and NON_COMPLIANT. Config does not support the
        /// 					NOT_APPLICABLE and
        /// 					INSUFFICIENT_DATA values.
        ///
        public let complianceType: ComplianceType?
        /// The name of the Config rule for which you want compliance
        /// 			information.
        public let configRuleName: String
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is 50. You cannot specify a number greater than 100. If
        /// 			you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(accountId: String, awsRegion: String, complianceType: ComplianceType? = nil, configRuleName: String, configurationAggregatorName: String, limit: Int? = nil, nextToken: String? = nil) {
            self.accountId = accountId
            self.awsRegion = awsRegion
            self.complianceType = complianceType
            self.configRuleName = configRuleName
            self.configurationAggregatorName = configurationAggregatorName
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, max: 64)
            try self.validate(self.awsRegion, name: "awsRegion", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case awsRegion = "AwsRegion"
            case complianceType = "ComplianceType"
            case configRuleName = "ConfigRuleName"
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateComplianceDetailsByConfigRuleResponse: AWSDecodableShape {
        /// Returns an AggregateEvaluationResults object.
        public let aggregateEvaluationResults: [AggregateEvaluationResult]?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregateEvaluationResults: [AggregateEvaluationResult]? = nil, nextToken: String? = nil) {
            self.aggregateEvaluationResults = aggregateEvaluationResults
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregateEvaluationResults = "AggregateEvaluationResults"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateConfigRuleComplianceSummaryRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the results based on the
        /// 			ConfigRuleComplianceSummaryFilters object.
        public let filters: ConfigRuleComplianceSummaryFilters?
        /// Groups the result based on ACCOUNT_ID or AWS_REGION.
        public let groupByKey: ConfigRuleComplianceSummaryGroupKey?
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is 1000. You cannot specify a number greater than 1000.
        /// 			If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, filters: ConfigRuleComplianceSummaryFilters? = nil, groupByKey: ConfigRuleComplianceSummaryGroupKey? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.groupByKey = groupByKey
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 1000)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case groupByKey = "GroupByKey"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateConfigRuleComplianceSummaryResponse: AWSDecodableShape {
        /// Returns a list of AggregateComplianceCounts object.
        public let aggregateComplianceCounts: [AggregateComplianceCount]?
        /// Groups the result based on ACCOUNT_ID or AWS_REGION.
        public let groupByKey: String?
        /// The nextToken string returned on a previous page that you use
        /// 			to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregateComplianceCounts: [AggregateComplianceCount]? = nil, groupByKey: String? = nil, nextToken: String? = nil) {
            self.aggregateComplianceCounts = aggregateComplianceCounts
            self.groupByKey = groupByKey
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregateComplianceCounts = "AggregateComplianceCounts"
            case groupByKey = "GroupByKey"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateConformancePackComplianceSummaryRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the results based on the AggregateConformancePackComplianceSummaryFilters object.
        public let filters: AggregateConformancePackComplianceSummaryFilters?
        /// Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.
        public let groupByKey: AggregateConformancePackComplianceSummaryGroupKey?
        /// The maximum number of results returned on each page. The default is maximum. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, filters: AggregateConformancePackComplianceSummaryFilters? = nil, groupByKey: AggregateConformancePackComplianceSummaryGroupKey? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.groupByKey = groupByKey
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case groupByKey = "GroupByKey"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateConformancePackComplianceSummaryResponse: AWSDecodableShape {
        /// Returns a list of AggregateConformancePackComplianceSummary object.
        public let aggregateConformancePackComplianceSummaries: [AggregateConformancePackComplianceSummary]?
        /// Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.
        public let groupByKey: String?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(aggregateConformancePackComplianceSummaries: [AggregateConformancePackComplianceSummary]? = nil, groupByKey: String? = nil, nextToken: String? = nil) {
            self.aggregateConformancePackComplianceSummaries = aggregateConformancePackComplianceSummaries
            self.groupByKey = groupByKey
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case aggregateConformancePackComplianceSummaries = "AggregateConformancePackComplianceSummaries"
            case groupByKey = "GroupByKey"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateDiscoveredResourceCountsRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the results based on the ResourceCountFilters object.
        public let filters: ResourceCountFilters?
        /// The key to group the resource counts.
        public let groupByKey: ResourceCountGroupKey?
        /// The maximum number of GroupedResourceCount objects returned on each page. The default is 1000. You cannot specify a number greater than 1000. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, filters: ResourceCountFilters? = nil, groupByKey: ResourceCountGroupKey? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.groupByKey = groupByKey
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 1000)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case groupByKey = "GroupByKey"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetAggregateDiscoveredResourceCountsResponse: AWSDecodableShape {
        /// The key passed into the request object. If GroupByKey is not provided, the result will be empty.
        public let groupByKey: String?
        /// Returns a list of GroupedResourceCount objects.
        public let groupedResourceCounts: [GroupedResourceCount]?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The total number of resources that are present in an aggregator with the filters that you provide.
        public let totalDiscoveredResources: Int64

        public init(groupByKey: String? = nil, groupedResourceCounts: [GroupedResourceCount]? = nil, nextToken: String? = nil, totalDiscoveredResources: Int64) {
            self.groupByKey = groupByKey
            self.groupedResourceCounts = groupedResourceCounts
            self.nextToken = nextToken
            self.totalDiscoveredResources = totalDiscoveredResources
        }

        private enum CodingKeys: String, CodingKey {
            case groupByKey = "GroupByKey"
            case groupedResourceCounts = "GroupedResourceCounts"
            case nextToken = "NextToken"
            case totalDiscoveredResources = "TotalDiscoveredResources"
        }
    }

    public struct GetAggregateResourceConfigRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// An object that identifies aggregate resource.
        public let resourceIdentifier: AggregateResourceIdentifier

        public init(configurationAggregatorName: String, resourceIdentifier: AggregateResourceIdentifier) {
            self.configurationAggregatorName = configurationAggregatorName
            self.resourceIdentifier = resourceIdentifier
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.resourceIdentifier.validate(name: "\(name).resourceIdentifier")
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case resourceIdentifier = "ResourceIdentifier"
        }
    }

    public struct GetAggregateResourceConfigResponse: AWSDecodableShape {
        /// Returns a ConfigurationItem object.
        public let configurationItem: ConfigurationItem?

        public init(configurationItem: ConfigurationItem? = nil) {
            self.configurationItem = configurationItem
        }

        private enum CodingKeys: String, CodingKey {
            case configurationItem = "ConfigurationItem"
        }
    }

    public struct GetComplianceDetailsByConfigRuleRequest: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT,
        /// 				NON_COMPLIANT, and
        /// 			NOT_APPLICABLE.
        public let complianceTypes: [ComplianceType]?
        /// The name of the Config rule for which you want compliance
        /// 			information.
        public let configRuleName: String
        /// The maximum number of evaluation results returned on each page.
        /// 			The default is 10. You cannot specify a number greater than 100. If
        /// 			you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?

        public init(complianceTypes: [ComplianceType]? = nil, configRuleName: String, limit: Int? = nil, nextToken: String? = nil) {
            self.complianceTypes = complianceTypes
            self.configRuleName = configRuleName
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.complianceTypes, name: "complianceTypes", parent: name, max: 3)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 64)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceTypes = "ComplianceTypes"
            case configRuleName = "ConfigRuleName"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetComplianceDetailsByConfigRuleResponse: AWSDecodableShape {
        /// Indicates whether the Amazon Web Services resource complies with the specified
        /// 			Config rule.
        public let evaluationResults: [EvaluationResult]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(evaluationResults: [EvaluationResult]? = nil, nextToken: String? = nil) {
            self.evaluationResults = evaluationResults
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationResults = "EvaluationResults"
            case nextToken = "NextToken"
        }
    }

    public struct GetComplianceDetailsByResourceRequest: AWSEncodableShape {
        /// Filters the results by compliance.
        /// 		       The allowed values are COMPLIANT,
        /// 				NON_COMPLIANT, and
        /// 			NOT_APPLICABLE.
        public let complianceTypes: [ComplianceType]?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// The unique ID of Amazon Web Services resource execution for which you want to retrieve evaluation results.
        /// 		        You need to only provide either a ResourceEvaluationID or a ResourceID and ResourceType.
        public let resourceEvaluationId: String?
        /// The ID of the Amazon Web Services resource for which you want compliance
        /// 			information.
        public let resourceId: String?
        /// The type of the Amazon Web Services resource for which you want compliance
        /// 			information.
        public let resourceType: String?

        public init(complianceTypes: [ComplianceType]? = nil, nextToken: String? = nil, resourceEvaluationId: String? = nil, resourceId: String? = nil, resourceType: String? = nil) {
            self.complianceTypes = complianceTypes
            self.nextToken = nextToken
            self.resourceEvaluationId = resourceEvaluationId
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.complianceTypes, name: "complianceTypes", parent: name, max: 3)
            try self.validate(self.resourceEvaluationId, name: "resourceEvaluationId", parent: name, max: 128)
            try self.validate(self.resourceEvaluationId, name: "resourceEvaluationId", parent: name, min: 1)
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 256)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceTypes = "ComplianceTypes"
            case nextToken = "NextToken"
            case resourceEvaluationId = "ResourceEvaluationId"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct GetComplianceDetailsByResourceResponse: AWSDecodableShape {
        /// Indicates whether the specified Amazon Web Services resource complies each Config rule.
        public let evaluationResults: [EvaluationResult]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(evaluationResults: [EvaluationResult]? = nil, nextToken: String? = nil) {
            self.evaluationResults = evaluationResults
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationResults = "EvaluationResults"
            case nextToken = "NextToken"
        }
    }

    public struct GetComplianceSummaryByConfigRuleResponse: AWSDecodableShape {
        /// The number of Config rules that are compliant and the
        /// 			number that are noncompliant, up to a maximum of 25 for
        /// 			each.
        public let complianceSummary: ComplianceSummary?

        public init(complianceSummary: ComplianceSummary? = nil) {
            self.complianceSummary = complianceSummary
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummary = "ComplianceSummary"
        }
    }

    public struct GetComplianceSummaryByResourceTypeRequest: AWSEncodableShape {
        /// Specify one or more resource types to get the number of
        /// 			resources that are compliant and the number that are noncompliant
        /// 			for each resource type.
        /// 		       For this request, you can specify an Amazon Web Services resource type such as
        /// 				AWS::EC2::Instance. You can specify that the
        /// 			resource type is an Amazon Web Services account by specifying
        /// 				AWS::::Account.
        public let resourceTypes: [String]?

        public init(resourceTypes: [String]? = nil) {
            self.resourceTypes = resourceTypes
        }

        public func validate(name: String) throws {
            try self.resourceTypes?.forEach {
                try validate($0, name: "resourceTypes[]", parent: name, max: 256)
                try validate($0, name: "resourceTypes[]", parent: name, min: 1)
            }
            try self.validate(self.resourceTypes, name: "resourceTypes", parent: name, max: 20)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceTypes = "ResourceTypes"
        }
    }

    public struct GetComplianceSummaryByResourceTypeResponse: AWSDecodableShape {
        /// The number of resources that are compliant and the number that
        /// 			are noncompliant. If one or more resource types were provided with
        /// 			the request, the numbers are returned for each resource type. The
        /// 			maximum number returned is 100.
        public let complianceSummariesByResourceType: [ComplianceSummaryByResourceType]?

        public init(complianceSummariesByResourceType: [ComplianceSummaryByResourceType]? = nil) {
            self.complianceSummariesByResourceType = complianceSummariesByResourceType
        }

        private enum CodingKeys: String, CodingKey {
            case complianceSummariesByResourceType = "ComplianceSummariesByResourceType"
        }
    }

    public struct GetConformancePackComplianceDetailsRequest: AWSEncodableShape {
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// A ConformancePackEvaluationFilters object.
        public let filters: ConformancePackEvaluationFilters?
        /// The maximum number of evaluation results returned on each page. If you do no specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackName: String, filters: ConformancePackEvaluationFilters? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.conformancePackName = conformancePackName
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, max: 256)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetConformancePackComplianceDetailsResponse: AWSDecodableShape {
        /// Name of the conformance pack.
        public let conformancePackName: String
        /// Returns a list of ConformancePackEvaluationResult objects.
        public let conformancePackRuleEvaluationResults: [ConformancePackEvaluationResult]?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackName: String, conformancePackRuleEvaluationResults: [ConformancePackEvaluationResult]? = nil, nextToken: String? = nil) {
            self.conformancePackName = conformancePackName
            self.conformancePackRuleEvaluationResults = conformancePackRuleEvaluationResults
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackName = "ConformancePackName"
            case conformancePackRuleEvaluationResults = "ConformancePackRuleEvaluationResults"
            case nextToken = "NextToken"
        }
    }

    public struct GetConformancePackComplianceSummaryRequest: AWSEncodableShape {
        /// Names of conformance packs.
        public let conformancePackNames: [String]
        /// The maximum number of conformance packs returned on each page.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackNames: [String], limit: Int? = nil, nextToken: String? = nil) {
            self.conformancePackNames = conformancePackNames
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.conformancePackNames.forEach {
                try validate($0, name: "conformancePackNames[]", parent: name, max: 256)
                try validate($0, name: "conformancePackNames[]", parent: name, min: 1)
                try validate($0, name: "conformancePackNames[]", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            }
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, max: 5)
            try self.validate(self.conformancePackNames, name: "conformancePackNames", parent: name, min: 1)
            try self.validate(self.limit, name: "limit", parent: name, max: 20)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackNames = "ConformancePackNames"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct GetConformancePackComplianceSummaryResponse: AWSDecodableShape {
        /// A list of ConformancePackComplianceSummary objects.
        public let conformancePackComplianceSummaryList: [ConformancePackComplianceSummary]?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackComplianceSummaryList: [ConformancePackComplianceSummary]? = nil, nextToken: String? = nil) {
            self.conformancePackComplianceSummaryList = conformancePackComplianceSummaryList
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackComplianceSummaryList = "ConformancePackComplianceSummaryList"
            case nextToken = "NextToken"
        }
    }

    public struct GetCustomRulePolicyRequest: AWSEncodableShape {
        /// The name of your Config Custom Policy rule.
        public let configRuleName: String?

        public init(configRuleName: String? = nil) {
            self.configRuleName = configRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
        }
    }

    public struct GetCustomRulePolicyResponse: AWSDecodableShape {
        /// The policy definition containing the logic for your Config Custom Policy rule.
        public let policyText: String?

        public init(policyText: String? = nil) {
            self.policyText = policyText
        }

        private enum CodingKeys: String, CodingKey {
            case policyText = "PolicyText"
        }
    }

    public struct GetDiscoveredResourceCountsRequest: AWSEncodableShape {
        /// The maximum number of ResourceCount objects
        /// 			returned on each page. The default is 100. You cannot specify a
        /// 			number greater than 100. If you specify 0, Config uses the
        /// 			default.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// The comma-separated list that specifies the resource types that
        /// 			you want Config to return (for example,
        /// 				"AWS::EC2::Instance",
        /// 			"AWS::IAM::User").
        /// 		       If a value for resourceTypes is not specified, Config returns all resource types that Config is recording in
        /// 			the region for your account.
        ///
        /// 			         If the configuration recorder is turned off, Config
        /// 				returns an empty list of ResourceCount
        /// 				objects. If the configuration recorder is not recording a
        /// 				specific resource type (for example, S3 buckets), that resource
        /// 				type is not returned in the list of ResourceCount objects.
        ///
        public let resourceTypes: [String]?

        public init(limit: Int? = nil, nextToken: String? = nil, resourceTypes: [String]? = nil) {
            self.limit = limit
            self.nextToken = nextToken
            self.resourceTypes = resourceTypes
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.resourceTypes?.forEach {
                try validate($0, name: "resourceTypes[]", parent: name, max: 256)
                try validate($0, name: "resourceTypes[]", parent: name, min: 1)
            }
            try self.validate(self.resourceTypes, name: "resourceTypes", parent: name, max: 20)
        }

        private enum CodingKeys: String, CodingKey {
            case limit
            case nextToken
            case resourceTypes
        }
    }

    public struct GetDiscoveredResourceCountsResponse: AWSDecodableShape {
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?
        /// The list of ResourceCount objects. Each object is
        /// 			listed in descending order by the number of resources.
        public let resourceCounts: [ResourceCount]?
        /// The total number of resources that Config is recording in
        /// 			the region for your account. If you specify resource types in the
        /// 			request, Config returns only the total number of resources for
        /// 			those resource types.
        /// 		        Example
        /// 				           Config is recording three resource types in the US
        /// 					East (Ohio) Region for your account: 25 EC2 instances, 20
        /// 					IAM users, and 15 S3 buckets, for a total of 60
        /// 					resources.
        ///
        /// 				           You make a call to the
        /// 						GetDiscoveredResourceCounts action and
        /// 					specify the resource type,
        /// 						"AWS::EC2::Instances", in the
        /// 					request.
        ///
        /// 				           Config returns 25 for
        /// 						totalDiscoveredResources.
        ///
        public let totalDiscoveredResources: Int64?

        public init(nextToken: String? = nil, resourceCounts: [ResourceCount]? = nil, totalDiscoveredResources: Int64? = nil) {
            self.nextToken = nextToken
            self.resourceCounts = resourceCounts
            self.totalDiscoveredResources = totalDiscoveredResources
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken
            case resourceCounts
            case totalDiscoveredResources
        }
    }

    public struct GetOrganizationConfigRuleDetailedStatusRequest: AWSEncodableShape {
        /// A StatusDetailFilters object.
        public let filters: StatusDetailFilters?
        /// The maximum number of OrganizationConfigRuleDetailedStatus returned on each page. If you do not specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The name of your organization Config rule for which you want status details for member accounts.
        public let organizationConfigRuleName: String

        public init(filters: StatusDetailFilters? = nil, limit: Int? = nil, nextToken: String? = nil, organizationConfigRuleName: String) {
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConfigRuleName = organizationConfigRuleName
        }

        public func validate(name: String) throws {
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, max: 64)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, min: 1)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConfigRuleName = "OrganizationConfigRuleName"
        }
    }

    public struct GetOrganizationConfigRuleDetailedStatusResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// A list of MemberAccountStatus objects.
        public let organizationConfigRuleDetailedStatus: [MemberAccountStatus]?

        public init(nextToken: String? = nil, organizationConfigRuleDetailedStatus: [MemberAccountStatus]? = nil) {
            self.nextToken = nextToken
            self.organizationConfigRuleDetailedStatus = organizationConfigRuleDetailedStatus
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConfigRuleDetailedStatus = "OrganizationConfigRuleDetailedStatus"
        }
    }

    public struct GetOrganizationConformancePackDetailedStatusRequest: AWSEncodableShape {
        /// An OrganizationResourceDetailedStatusFilters object.
        public let filters: OrganizationResourceDetailedStatusFilters?
        /// The maximum number of OrganizationConformancePackDetailedStatuses returned on each page.
        /// 			If you do not specify a number, Config uses the default. The default is 100.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The name of organization conformance pack for which you want status details for member accounts.
        public let organizationConformancePackName: String

        public init(filters: OrganizationResourceDetailedStatusFilters? = nil, limit: Int? = nil, nextToken: String? = nil, organizationConformancePackName: String) {
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
            self.organizationConformancePackName = organizationConformancePackName
        }

        public func validate(name: String) throws {
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, max: 128)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, min: 1)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
            case organizationConformancePackName = "OrganizationConformancePackName"
        }
    }

    public struct GetOrganizationConformancePackDetailedStatusResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// A list of OrganizationConformancePackDetailedStatus objects.
        public let organizationConformancePackDetailedStatuses: [OrganizationConformancePackDetailedStatus]?

        public init(nextToken: String? = nil, organizationConformancePackDetailedStatuses: [OrganizationConformancePackDetailedStatus]? = nil) {
            self.nextToken = nextToken
            self.organizationConformancePackDetailedStatuses = organizationConformancePackDetailedStatuses
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case organizationConformancePackDetailedStatuses = "OrganizationConformancePackDetailedStatuses"
        }
    }

    public struct GetOrganizationCustomRulePolicyRequest: AWSEncodableShape {
        /// The name of your organization Config Custom Policy rule.
        public let organizationConfigRuleName: String

        public init(organizationConfigRuleName: String) {
            self.organizationConfigRuleName = organizationConfigRuleName
        }

        public func validate(name: String) throws {
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, max: 64)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, min: 1)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, pattern: "\\S")
        }

        private enum CodingKeys: String, CodingKey {
            case organizationConfigRuleName = "OrganizationConfigRuleName"
        }
    }

    public struct GetOrganizationCustomRulePolicyResponse: AWSDecodableShape {
        /// The policy definition containing the logic for your organization Config Custom Policy rule.
        public let policyText: String?

        public init(policyText: String? = nil) {
            self.policyText = policyText
        }

        private enum CodingKeys: String, CodingKey {
            case policyText = "PolicyText"
        }
    }

    public struct GetResourceConfigHistoryRequest: AWSEncodableShape {
        /// The chronological order for configuration items listed. By
        /// 			default, the results are listed in reverse chronological
        /// 			order.
        public let chronologicalOrder: ChronologicalOrder?
        /// The time stamp that indicates an earlier time. If not
        /// 			specified, the action returns paginated results that contain
        /// 			configuration items that start when the first configuration item was
        /// 			recorded.
        public let earlierTime: Date?
        /// The time stamp that indicates a later time. If not specified,
        /// 			current time is taken.
        public let laterTime: Date?
        /// The maximum number of configuration items returned on each
        /// 			page. The default is 10. You cannot specify a number greater than
        /// 			100. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// The ID of the resource (for example.,
        /// 			sg-xxxxxx).
        public let resourceId: String
        /// The resource type.
        public let resourceType: ResourceType

        public init(chronologicalOrder: ChronologicalOrder? = nil, earlierTime: Date? = nil, laterTime: Date? = nil, limit: Int? = nil, nextToken: String? = nil, resourceId: String, resourceType: ResourceType) {
            self.chronologicalOrder = chronologicalOrder
            self.earlierTime = earlierTime
            self.laterTime = laterTime
            self.limit = limit
            self.nextToken = nextToken
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case chronologicalOrder
            case earlierTime
            case laterTime
            case limit
            case nextToken
            case resourceId
            case resourceType
        }
    }

    public struct GetResourceConfigHistoryResponse: AWSDecodableShape {
        /// A list that contains the configuration history of one or more
        /// 			resources.
        public let configurationItems: [ConfigurationItem]?
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?

        public init(configurationItems: [ConfigurationItem]? = nil, nextToken: String? = nil) {
            self.configurationItems = configurationItems
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case configurationItems
            case nextToken
        }
    }

    public struct GetResourceEvaluationSummaryRequest: AWSEncodableShape {
        /// The unique ResourceEvaluationId of Amazon Web Services resource execution for which you want to retrieve the evaluation summary.
        public let resourceEvaluationId: String

        public init(resourceEvaluationId: String) {
            self.resourceEvaluationId = resourceEvaluationId
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceEvaluationId, name: "resourceEvaluationId", parent: name, max: 128)
            try self.validate(self.resourceEvaluationId, name: "resourceEvaluationId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceEvaluationId = "ResourceEvaluationId"
        }
    }

    public struct GetResourceEvaluationSummaryResponse: AWSDecodableShape {
        /// The compliance status of the resource evaluation summary.
        public let compliance: ComplianceType?
        /// Returns an EvaluationContext object.
        public let evaluationContext: EvaluationContext?
        /// Lists results of the mode that you requested to retrieve the resource evaluation summary. The valid values are Detective or Proactive.
        public let evaluationMode: EvaluationMode?
        /// The start timestamp when Config rule starts evaluating compliance for the provided resource details.
        public let evaluationStartTimestamp: Date?
        /// Returns an EvaluationStatus object.
        public let evaluationStatus: EvaluationStatus?
        /// Returns a ResourceDetails object.
        public let resourceDetails: ResourceDetails?
        /// The unique ResourceEvaluationId of Amazon Web Services resource execution for which you want to retrieve the evaluation summary.
        public let resourceEvaluationId: String?

        public init(compliance: ComplianceType? = nil, evaluationContext: EvaluationContext? = nil, evaluationMode: EvaluationMode? = nil, evaluationStartTimestamp: Date? = nil, evaluationStatus: EvaluationStatus? = nil, resourceDetails: ResourceDetails? = nil, resourceEvaluationId: String? = nil) {
            self.compliance = compliance
            self.evaluationContext = evaluationContext
            self.evaluationMode = evaluationMode
            self.evaluationStartTimestamp = evaluationStartTimestamp
            self.evaluationStatus = evaluationStatus
            self.resourceDetails = resourceDetails
            self.resourceEvaluationId = resourceEvaluationId
        }

        private enum CodingKeys: String, CodingKey {
            case compliance = "Compliance"
            case evaluationContext = "EvaluationContext"
            case evaluationMode = "EvaluationMode"
            case evaluationStartTimestamp = "EvaluationStartTimestamp"
            case evaluationStatus = "EvaluationStatus"
            case resourceDetails = "ResourceDetails"
            case resourceEvaluationId = "ResourceEvaluationId"
        }
    }

    public struct GetStoredQueryRequest: AWSEncodableShape {
        /// The name of the query.
        public let queryName: String

        public init(queryName: String) {
            self.queryName = queryName
        }

        public func validate(name: String) throws {
            try self.validate(self.queryName, name: "queryName", parent: name, max: 64)
            try self.validate(self.queryName, name: "queryName", parent: name, min: 1)
            try self.validate(self.queryName, name: "queryName", parent: name, pattern: "^[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case queryName = "QueryName"
        }
    }

    public struct GetStoredQueryResponse: AWSDecodableShape {
        /// Returns a StoredQuery object.
        public let storedQuery: StoredQuery?

        public init(storedQuery: StoredQuery? = nil) {
            self.storedQuery = storedQuery
        }

        private enum CodingKeys: String, CodingKey {
            case storedQuery = "StoredQuery"
        }
    }

    public struct GroupedResourceCount: AWSDecodableShape {
        /// The name of the group that can be region, account ID, or resource type. For example, region1, region2 if the region was chosen as GroupByKey.
        public let groupName: String
        /// The number of resources in the group.
        public let resourceCount: Int64

        public init(groupName: String, resourceCount: Int64) {
            self.groupName = groupName
            self.resourceCount = resourceCount
        }

        private enum CodingKeys: String, CodingKey {
            case groupName = "GroupName"
            case resourceCount = "ResourceCount"
        }
    }

    public struct ListAggregateDiscoveredResourcesRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// Filters the results based on the ResourceFilters object.
        public let filters: ResourceFilters?
        /// The maximum number of resource identifiers returned on each page. You cannot specify a number greater than 100. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The type of resources that you want Config to list in the response.
        public let resourceType: ResourceType

        public init(configurationAggregatorName: String, filters: ResourceFilters? = nil, limit: Int? = nil, nextToken: String? = nil, resourceType: ResourceType) {
            self.configurationAggregatorName = configurationAggregatorName
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
            case resourceType = "ResourceType"
        }
    }

    public struct ListAggregateDiscoveredResourcesResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a list of ResourceIdentifiers objects.
        public let resourceIdentifiers: [AggregateResourceIdentifier]?

        public init(nextToken: String? = nil, resourceIdentifiers: [AggregateResourceIdentifier]? = nil) {
            self.nextToken = nextToken
            self.resourceIdentifiers = resourceIdentifiers
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case resourceIdentifiers = "ResourceIdentifiers"
        }
    }

    public struct ListConformancePackComplianceScoresRequest: AWSEncodableShape {
        /// Filters the results based on the ConformancePackComplianceScoresFilters.
        public let filters: ConformancePackComplianceScoresFilters?
        /// The maximum number of conformance pack compliance scores returned on each page.
        public let limit: Int?
        /// The nextToken string in a prior request that you can use to get the paginated response for next set of conformance pack compliance scores.
        public let nextToken: String?
        /// Sorts your conformance pack compliance scores in either ascending or descending order, depending on SortOrder.
        /// 		       By default, conformance pack compliance scores are sorted in alphabetical order by name of the conformance pack.
        /// 			Enter SCORE, to sort conformance pack compliance scores by the numerical value of the compliance score.
        public let sortBy: SortBy?
        /// Determines the order in which conformance pack compliance scores are sorted. Either in ascending or descending order.
        ///
        /// 		       By default, conformance pack compliance scores are sorted in alphabetical order by name of the conformance pack. Conformance pack compliance scores are sorted in reverse alphabetical order if you enter DESCENDING.
        ///
        /// 		       You can sort conformance pack compliance scores by the numerical value of the compliance score by entering SCORE in the SortBy action. When compliance scores are sorted by SCORE, conformance packs with a compliance score of INSUFFICIENT_DATA will be last when sorting by ascending order and first when sorting by descending order.
        public let sortOrder: SortOrder?

        public init(filters: ConformancePackComplianceScoresFilters? = nil, limit: Int? = nil, nextToken: String? = nil, sortBy: SortBy? = nil, sortOrder: SortOrder? = nil) {
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
            self.sortBy = sortBy
            self.sortOrder = sortOrder
        }

        public func validate(name: String) throws {
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 20)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
            case sortBy = "SortBy"
            case sortOrder = "SortOrder"
        }
    }

    public struct ListConformancePackComplianceScoresResponse: AWSDecodableShape {
        /// A list of ConformancePackComplianceScore objects.
        public let conformancePackComplianceScores: [ConformancePackComplianceScore]
        /// The nextToken string that you can use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(conformancePackComplianceScores: [ConformancePackComplianceScore], nextToken: String? = nil) {
            self.conformancePackComplianceScores = conformancePackComplianceScores
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackComplianceScores = "ConformancePackComplianceScores"
            case nextToken = "NextToken"
        }
    }

    public struct ListDiscoveredResourcesRequest: AWSEncodableShape {
        /// Specifies whether Config includes deleted resources in the
        /// 			results. By default, deleted resources are not included.
        public let includeDeletedResources: Bool?
        /// The maximum number of resource identifiers returned on each
        /// 			page. The default is 100. You cannot specify a number greater than
        /// 			100. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page
        /// 			that you use to get the next page of results in a paginated
        /// 			response.
        public let nextToken: String?
        /// The IDs of only those resources that you want Config to
        /// 			list in the response. If you do not specify this parameter, Config lists all resources of the specified type that it has
        /// 			discovered.
        public let resourceIds: [String]?
        /// The custom name of only those resources that you want Config to list in the response. If you do not specify this
        /// 			parameter, Config lists all resources of the specified type that
        /// 			it has discovered.
        public let resourceName: String?
        /// The type of resources that you want Config to list in the
        /// 			response.
        public let resourceType: ResourceType

        public init(includeDeletedResources: Bool? = nil, limit: Int? = nil, nextToken: String? = nil, resourceIds: [String]? = nil, resourceName: String? = nil, resourceType: ResourceType) {
            self.includeDeletedResources = includeDeletedResources
            self.limit = limit
            self.nextToken = nextToken
            self.resourceIds = resourceIds
            self.resourceName = resourceName
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.resourceIds?.forEach {
                try validate($0, name: "resourceIds[]", parent: name, max: 768)
                try validate($0, name: "resourceIds[]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case includeDeletedResources
            case limit
            case nextToken
            case resourceIds
            case resourceName
            case resourceType
        }
    }

    public struct ListDiscoveredResourcesResponse: AWSDecodableShape {
        /// The string that you use in a subsequent request to get the next
        /// 			page of results in a paginated response.
        public let nextToken: String?
        /// The details that identify a resource that is discovered by Config, including the resource type, ID, and (if available) the
        /// 			custom resource name.
        public let resourceIdentifiers: [ResourceIdentifier]?

        public init(nextToken: String? = nil, resourceIdentifiers: [ResourceIdentifier]? = nil) {
            self.nextToken = nextToken
            self.resourceIdentifiers = resourceIdentifiers
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken
            case resourceIdentifiers
        }
    }

    public struct ListResourceEvaluationsRequest: AWSEncodableShape {
        /// Returns a ResourceEvaluationFilters object.
        public let filters: ResourceEvaluationFilters?
        /// The maximum number of evaluations returned on each page. The default is 10.
        /// 			You cannot specify a number greater than 100. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?

        public init(filters: ResourceEvaluationFilters? = nil, limit: Int? = nil, nextToken: String? = nil) {
            self.filters = filters
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.filters?.validate(name: "\(name).filters")
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct ListResourceEvaluationsResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns a ResourceEvaluations object.
        public let resourceEvaluations: [ResourceEvaluation]?

        public init(nextToken: String? = nil, resourceEvaluations: [ResourceEvaluation]? = nil) {
            self.nextToken = nextToken
            self.resourceEvaluations = resourceEvaluations
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case resourceEvaluations = "ResourceEvaluations"
        }
    }

    public struct ListStoredQueriesRequest: AWSEncodableShape {
        /// The maximum number of results to be returned with a single call.
        public let maxResults: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(maxResults: Int? = nil, nextToken: String? = nil) {
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case maxResults = "MaxResults"
            case nextToken = "NextToken"
        }
    }

    public struct ListStoredQueriesResponse: AWSDecodableShape {
        /// If the previous paginated request didn't return all of the remaining results, the response object's NextToken parameter value is set to a token.
        /// 			To retrieve the next set of results, call this action again and assign that token to the request object's NextToken parameter.
        /// 			If there are no remaining results, the previous response object's NextToken parameter is set to null.
        public let nextToken: String?
        /// A list of StoredQueryMetadata objects.
        public let storedQueryMetadata: [StoredQueryMetadata]?

        public init(nextToken: String? = nil, storedQueryMetadata: [StoredQueryMetadata]? = nil) {
            self.nextToken = nextToken
            self.storedQueryMetadata = storedQueryMetadata
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case storedQueryMetadata = "StoredQueryMetadata"
        }
    }

    public struct ListTagsForResourceRequest: AWSEncodableShape {
        /// The maximum number of tags returned on each page. The limit maximum is 50. You cannot specify a number greater than 50. If you specify 0, Config uses the default.
        public let limit: Int?
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are ConfigRule, ConfigurationAggregator and AggregatorAuthorization.
        public let resourceArn: String

        public init(limit: Int? = nil, nextToken: String? = nil, resourceArn: String) {
            self.limit = limit
            self.nextToken = nextToken
            self.resourceArn = resourceArn
        }

        public func validate(name: String) throws {
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 1000)
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
            case resourceArn = "ResourceArn"
        }
    }

    public struct ListTagsForResourceResponse: AWSDecodableShape {
        /// The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.
        public let nextToken: String?
        /// The tags for the resource.
        public let tags: [Tag]?

        public init(nextToken: String? = nil, tags: [Tag]? = nil) {
            self.nextToken = nextToken
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case tags = "Tags"
        }
    }

    public struct MemberAccountStatus: AWSDecodableShape {
        /// The 12-digit account ID of a member account.
        public let accountId: String
        /// The name of Config rule deployed in the member account.
        public let configRuleName: String
        /// An error code that is returned when Config rule creation or deletion failed in the member account.
        public let errorCode: String?
        /// An error message indicating that Config rule account creation or deletion has failed due to an error in the member account.
        public let errorMessage: String?
        /// The timestamp of the last status update.
        public let lastUpdateTime: Date?
        /// Indicates deployment status for Config rule in the member account.
        /// 			When management account calls PutOrganizationConfigRule action for the first time, Config rule status is created in the member account.
        /// 			When management account calls PutOrganizationConfigRule action for the second time, Config rule status is updated in the member account.
        /// 			Config rule status is deleted when the management account deletes OrganizationConfigRule and disables service access for config-multiaccountsetup.amazonaws.com.
        ///
        /// 		        Config sets the state of the rule to:
        /// 		          CREATE_SUCCESSFUL when Config rule has been created in the member account.     CREATE_IN_PROGRESS when Config rule is being created in the member account.    CREATE_FAILED when Config rule creation has failed in the member account.    DELETE_FAILED when Config rule deletion has failed in the member account.    DELETE_IN_PROGRESS when Config rule is being deleted in the member account.    DELETE_SUCCESSFUL when Config rule has been deleted in the member account.     UPDATE_SUCCESSFUL when Config rule has been updated in the member account.    UPDATE_IN_PROGRESS when Config rule is being updated in the member account.    UPDATE_FAILED when Config rule deletion has failed in the member account.
        public let memberAccountRuleStatus: MemberAccountRuleStatus

        public init(accountId: String, configRuleName: String, errorCode: String? = nil, errorMessage: String? = nil, lastUpdateTime: Date? = nil, memberAccountRuleStatus: MemberAccountRuleStatus) {
            self.accountId = accountId
            self.configRuleName = configRuleName
            self.errorCode = errorCode
            self.errorMessage = errorMessage
            self.lastUpdateTime = lastUpdateTime
            self.memberAccountRuleStatus = memberAccountRuleStatus
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case configRuleName = "ConfigRuleName"
            case errorCode = "ErrorCode"
            case errorMessage = "ErrorMessage"
            case lastUpdateTime = "LastUpdateTime"
            case memberAccountRuleStatus = "MemberAccountRuleStatus"
        }
    }

    public struct OrganizationAggregationSource: AWSEncodableShape & AWSDecodableShape {
        /// If true, aggregate existing Config regions and future
        /// 			regions.
        public let allAwsRegions: Bool?
        /// The source regions being aggregated.
        public let awsRegions: [String]?
        /// ARN of the IAM role used to retrieve Amazon Web Services Organization details
        /// 			associated with the aggregator account.
        public let roleArn: String

        public init(allAwsRegions: Bool? = nil, awsRegions: [String]? = nil, roleArn: String) {
            self.allAwsRegions = allAwsRegions
            self.awsRegions = awsRegions
            self.roleArn = roleArn
        }

        public func validate(name: String) throws {
            try self.validate(self.awsRegions, name: "awsRegions", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case allAwsRegions = "AllAwsRegions"
            case awsRegions = "AwsRegions"
            case roleArn = "RoleArn"
        }
    }

    public struct OrganizationConfigRule: AWSDecodableShape {
        /// A comma-separated list of accounts excluded from organization Config rule.
        public let excludedAccounts: [String]?
        /// The timestamp of the last update.
        public let lastUpdateTime: Date?
        /// Amazon Resource Name (ARN) of organization Config rule.
        public let organizationConfigRuleArn: String
        /// The name that you assign to organization Config rule.
        public let organizationConfigRuleName: String
        /// An
        /// 			object that specifies metadata for your organization's Config Custom Policy rule. The metadata includes the runtime system in use, which accounts have
        /// 			debug logging enabled, and other custom rule metadata, such as resource type, resource
        /// 			ID of Amazon Web Services resource, and organization trigger types that initiate Config to evaluate Amazon Web Services resources against a rule.
        public let organizationCustomPolicyRuleMetadata: OrganizationCustomPolicyRuleMetadataNoPolicy?
        /// An OrganizationCustomRuleMetadata object.
        public let organizationCustomRuleMetadata: OrganizationCustomRuleMetadata?
        /// An OrganizationManagedRuleMetadata object.
        public let organizationManagedRuleMetadata: OrganizationManagedRuleMetadata?

        public init(excludedAccounts: [String]? = nil, lastUpdateTime: Date? = nil, organizationConfigRuleArn: String, organizationConfigRuleName: String, organizationCustomPolicyRuleMetadata: OrganizationCustomPolicyRuleMetadataNoPolicy? = nil, organizationCustomRuleMetadata: OrganizationCustomRuleMetadata? = nil, organizationManagedRuleMetadata: OrganizationManagedRuleMetadata? = nil) {
            self.excludedAccounts = excludedAccounts
            self.lastUpdateTime = lastUpdateTime
            self.organizationConfigRuleArn = organizationConfigRuleArn
            self.organizationConfigRuleName = organizationConfigRuleName
            self.organizationCustomPolicyRuleMetadata = organizationCustomPolicyRuleMetadata
            self.organizationCustomRuleMetadata = organizationCustomRuleMetadata
            self.organizationManagedRuleMetadata = organizationManagedRuleMetadata
        }

        private enum CodingKeys: String, CodingKey {
            case excludedAccounts = "ExcludedAccounts"
            case lastUpdateTime = "LastUpdateTime"
            case organizationConfigRuleArn = "OrganizationConfigRuleArn"
            case organizationConfigRuleName = "OrganizationConfigRuleName"
            case organizationCustomPolicyRuleMetadata = "OrganizationCustomPolicyRuleMetadata"
            case organizationCustomRuleMetadata = "OrganizationCustomRuleMetadata"
            case organizationManagedRuleMetadata = "OrganizationManagedRuleMetadata"
        }
    }

    public struct OrganizationConfigRuleStatus: AWSDecodableShape {
        /// An error code that is returned when organization Config rule creation or deletion has failed.
        public let errorCode: String?
        /// An error message indicating that organization Config rule creation or deletion failed due to an error.
        public let errorMessage: String?
        /// The timestamp of the last update.
        public let lastUpdateTime: Date?
        /// The name that you assign to organization Config rule.
        public let organizationConfigRuleName: String
        /// Indicates deployment status of an organization Config rule.
        /// 			When management account calls PutOrganizationConfigRule action for the first time, Config rule status is created in all the member accounts.
        /// 			When management account calls PutOrganizationConfigRule action for the second time, Config rule status is updated in all the member accounts. Additionally, Config rule status is updated when one or more member accounts join or leave an organization.
        /// 			Config rule status is deleted when the management account deletes OrganizationConfigRule in all the member accounts and disables service access for config-multiaccountsetup.amazonaws.com.
        /// 			      Config sets the state of the rule to:
        /// 		          CREATE_SUCCESSFUL when an organization Config rule has been successfully created in all the member accounts.     CREATE_IN_PROGRESS when an organization Config rule creation is in progress.    CREATE_FAILED when an organization Config rule creation failed in one or more member accounts within that organization.    DELETE_FAILED when an organization Config rule deletion failed in one or more member accounts within that organization.    DELETE_IN_PROGRESS when an organization Config rule deletion is in progress.    DELETE_SUCCESSFUL when an organization Config rule has been successfully deleted from all the member accounts.    UPDATE_SUCCESSFUL when an organization Config rule has been successfully updated in all the member accounts.    UPDATE_IN_PROGRESS when an organization Config rule update is in progress.    UPDATE_FAILED when an organization Config rule update failed in one or more member accounts within that organization.
        public let organizationRuleStatus: OrganizationRuleStatus

        public init(errorCode: String? = nil, errorMessage: String? = nil, lastUpdateTime: Date? = nil, organizationConfigRuleName: String, organizationRuleStatus: OrganizationRuleStatus) {
            self.errorCode = errorCode
            self.errorMessage = errorMessage
            self.lastUpdateTime = lastUpdateTime
            self.organizationConfigRuleName = organizationConfigRuleName
            self.organizationRuleStatus = organizationRuleStatus
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode = "ErrorCode"
            case errorMessage = "ErrorMessage"
            case lastUpdateTime = "LastUpdateTime"
            case organizationConfigRuleName = "OrganizationConfigRuleName"
            case organizationRuleStatus = "OrganizationRuleStatus"
        }
    }

    public struct OrganizationConformancePack: AWSDecodableShape {
        /// A list of ConformancePackInputParameter objects.
        public let conformancePackInputParameters: [ConformancePackInputParameter]?
        /// The name of the Amazon S3 bucket where Config stores conformance pack templates.
        /// 		        This field is optional.
        public let deliveryS3Bucket: String?
        /// Any folder structure you want to add to an Amazon S3 bucket.
        /// 		        This field is optional.
        public let deliveryS3KeyPrefix: String?
        /// A comma-separated list of accounts excluded from organization conformance pack.
        public let excludedAccounts: [String]?
        /// Last time when organization conformation pack was updated.
        public let lastUpdateTime: Date
        /// Amazon Resource Name (ARN) of organization conformance pack.
        public let organizationConformancePackArn: String
        /// The name you assign to an organization conformance pack.
        public let organizationConformancePackName: String

        public init(conformancePackInputParameters: [ConformancePackInputParameter]? = nil, deliveryS3Bucket: String? = nil, deliveryS3KeyPrefix: String? = nil, excludedAccounts: [String]? = nil, lastUpdateTime: Date, organizationConformancePackArn: String, organizationConformancePackName: String) {
            self.conformancePackInputParameters = conformancePackInputParameters
            self.deliveryS3Bucket = deliveryS3Bucket
            self.deliveryS3KeyPrefix = deliveryS3KeyPrefix
            self.excludedAccounts = excludedAccounts
            self.lastUpdateTime = lastUpdateTime
            self.organizationConformancePackArn = organizationConformancePackArn
            self.organizationConformancePackName = organizationConformancePackName
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackInputParameters = "ConformancePackInputParameters"
            case deliveryS3Bucket = "DeliveryS3Bucket"
            case deliveryS3KeyPrefix = "DeliveryS3KeyPrefix"
            case excludedAccounts = "ExcludedAccounts"
            case lastUpdateTime = "LastUpdateTime"
            case organizationConformancePackArn = "OrganizationConformancePackArn"
            case organizationConformancePackName = "OrganizationConformancePackName"
        }
    }

    public struct OrganizationConformancePackDetailedStatus: AWSDecodableShape {
        /// The 12-digit account ID of a member account.
        public let accountId: String
        /// The name of conformance pack deployed in the member account.
        public let conformancePackName: String
        /// An error code that is returned when conformance pack creation or
        /// 			deletion failed in the member account.
        public let errorCode: String?
        /// An error message indicating that conformance pack account creation or deletion
        /// 			has failed due to an error in the member account.
        public let errorMessage: String?
        /// The timestamp of the last status update.
        public let lastUpdateTime: Date?
        /// Indicates deployment status for conformance pack in a member account.
        /// 			When management account calls PutOrganizationConformancePack action for the first time, conformance pack status is created in the member account.
        /// 			When management account calls PutOrganizationConformancePack action for the second time, conformance pack status is updated in the member account.
        /// 			Conformance pack status is deleted when the management account deletes OrganizationConformancePack and disables service access for config-multiaccountsetup.amazonaws.com.
        ///
        /// 		        Config sets the state of the conformance pack to:
        /// 		          CREATE_SUCCESSFUL when conformance pack has been created in the member account.     CREATE_IN_PROGRESS when conformance pack is being created in the member account.    CREATE_FAILED when conformance pack creation has failed in the member account.    DELETE_FAILED when conformance pack deletion has failed in the member account.    DELETE_IN_PROGRESS when conformance pack is being deleted in the member account.    DELETE_SUCCESSFUL when conformance pack has been deleted in the member account.     UPDATE_SUCCESSFUL when conformance pack has been updated in the member account.    UPDATE_IN_PROGRESS when conformance pack is being updated in the member account.    UPDATE_FAILED when conformance pack deletion has failed in the member account.
        public let status: OrganizationResourceDetailedStatus

        public init(accountId: String, conformancePackName: String, errorCode: String? = nil, errorMessage: String? = nil, lastUpdateTime: Date? = nil, status: OrganizationResourceDetailedStatus) {
            self.accountId = accountId
            self.conformancePackName = conformancePackName
            self.errorCode = errorCode
            self.errorMessage = errorMessage
            self.lastUpdateTime = lastUpdateTime
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case conformancePackName = "ConformancePackName"
            case errorCode = "ErrorCode"
            case errorMessage = "ErrorMessage"
            case lastUpdateTime = "LastUpdateTime"
            case status = "Status"
        }
    }

    public struct OrganizationConformancePackStatus: AWSDecodableShape {
        /// An error code that is returned when organization conformance pack creation or deletion has failed in a member account.
        public let errorCode: String?
        /// An error message indicating that organization conformance pack creation or deletion failed due to an error.
        public let errorMessage: String?
        /// The timestamp of the last update.
        public let lastUpdateTime: Date?
        /// The name that you assign to organization conformance pack.
        public let organizationConformancePackName: String
        /// Indicates deployment status of an organization conformance pack.
        /// 			When management account calls PutOrganizationConformancePack for the first time,
        /// 			conformance pack status is created in all the member accounts.
        /// 			When management account calls PutOrganizationConformancePack for the second time,
        /// 			conformance pack status is updated in all the member accounts.
        /// 			Additionally, conformance pack status is updated when one or more member accounts join or leave an
        /// 			organization.
        /// 			Conformance pack status is deleted when the management account deletes
        /// 			OrganizationConformancePack in all the member accounts and disables service
        /// 			access for config-multiaccountsetup.amazonaws.com.
        /// 		       Config sets the state of the conformance pack to:
        /// 		          CREATE_SUCCESSFUL when an organization conformance pack has been successfully created in all the member accounts.     CREATE_IN_PROGRESS when an organization conformance pack creation is in progress.    CREATE_FAILED when an organization conformance pack creation failed in one or more member accounts within that organization.    DELETE_FAILED when an organization conformance pack deletion failed in one or more member accounts within that organization.    DELETE_IN_PROGRESS when an organization conformance pack deletion is in progress.    DELETE_SUCCESSFUL when an organization conformance pack has been successfully deleted from all the member accounts.    UPDATE_SUCCESSFUL when an organization conformance pack has been successfully updated in all the member accounts.    UPDATE_IN_PROGRESS when an organization conformance pack update is in progress.    UPDATE_FAILED when an organization conformance pack update failed in one or more member accounts within that organization.
        public let status: OrganizationResourceStatus

        public init(errorCode: String? = nil, errorMessage: String? = nil, lastUpdateTime: Date? = nil, organizationConformancePackName: String, status: OrganizationResourceStatus) {
            self.errorCode = errorCode
            self.errorMessage = errorMessage
            self.lastUpdateTime = lastUpdateTime
            self.organizationConformancePackName = organizationConformancePackName
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode = "ErrorCode"
            case errorMessage = "ErrorMessage"
            case lastUpdateTime = "LastUpdateTime"
            case organizationConformancePackName = "OrganizationConformancePackName"
            case status = "Status"
        }
    }

    public struct OrganizationCustomPolicyRuleMetadata: AWSEncodableShape {
        /// A list of accounts that you can enable debug logging for your organization Config Custom Policy rule. List is null when debug logging is enabled for all accounts.
        public let debugLogDeliveryAccounts: [String]?
        /// The description that you provide for your organization Config Custom Policy rule.
        public let description: String?
        /// A string, in JSON format, that is passed to your organization Config Custom Policy rule.
        public let inputParameters: String?
        /// The maximum frequency with which Config runs evaluations for a rule. Your
        /// 			Config Custom Policy rule is triggered when Config delivers
        /// 			the configuration snapshot. For more information, see ConfigSnapshotDeliveryProperties.
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// The type of notification that initiates Config to run an evaluation for a rule.
        /// 			For Config Custom Policy rules, Config supports change-initiated notification types:
        ///
        /// 		          ConfigurationItemChangeNotification - Initiates an evaluation when Config delivers a configuration item as a result of a resource
        /// 					change.    OversizedConfigurationItemChangeNotification - Initiates an evaluation when
        /// 						Config delivers an oversized configuration item. Config may generate this notification type when a resource changes and the
        /// 					notification exceeds the maximum size allowed by Amazon SNS.
        public let organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerTypeNoSN]?
        /// The runtime system for your organization Config Custom Policy rules. Guard is a policy-as-code language that allows you to write policies that are enforced by Config Custom Policy rules. For more information about Guard, see the Guard GitHub
        /// 			Repository.
        public let policyRuntime: String
        /// The policy definition containing the logic for your organization Config Custom Policy rule.
        public let policyText: String
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let resourceIdScope: String?
        /// The type of the Amazon Web Services resource that was evaluated.
        public let resourceTypesScope: [String]?
        /// One part of a key-value pair that make up a tag. A key is a general label that acts like a category for more specific tag values.
        public let tagKeyScope: String?
        /// The optional part of a key-value pair that make up a tag. A value acts as a descriptor within a tag category (key).
        public let tagValueScope: String?

        public init(debugLogDeliveryAccounts: [String]? = nil, description: String? = nil, inputParameters: String? = nil, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerTypeNoSN]? = nil, policyRuntime: String, policyText: String, resourceIdScope: String? = nil, resourceTypesScope: [String]? = nil, tagKeyScope: String? = nil, tagValueScope: String? = nil) {
            self.debugLogDeliveryAccounts = debugLogDeliveryAccounts
            self.description = description
            self.inputParameters = inputParameters
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.organizationConfigRuleTriggerTypes = organizationConfigRuleTriggerTypes
            self.policyRuntime = policyRuntime
            self.policyText = policyText
            self.resourceIdScope = resourceIdScope
            self.resourceTypesScope = resourceTypesScope
            self.tagKeyScope = tagKeyScope
            self.tagValueScope = tagValueScope
        }

        public func validate(name: String) throws {
            try self.debugLogDeliveryAccounts?.forEach {
                try validate($0, name: "debugLogDeliveryAccounts[]", parent: name, pattern: "^\\d{12}$")
            }
            try self.validate(self.debugLogDeliveryAccounts, name: "debugLogDeliveryAccounts", parent: name, max: 1000)
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, max: 2048)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, min: 1)
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, max: 64)
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, min: 1)
            try self.validate(self.policyRuntime, name: "policyRuntime", parent: name, pattern: "^guard\\-2\\.x\\.x$")
            try self.validate(self.policyText, name: "policyText", parent: name, max: 10000)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, max: 768)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, min: 1)
            try self.resourceTypesScope?.forEach {
                try validate($0, name: "resourceTypesScope[]", parent: name, max: 256)
                try validate($0, name: "resourceTypesScope[]", parent: name, min: 1)
            }
            try self.validate(self.resourceTypesScope, name: "resourceTypesScope", parent: name, max: 100)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, max: 128)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, min: 1)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, max: 256)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case debugLogDeliveryAccounts = "DebugLogDeliveryAccounts"
            case description = "Description"
            case inputParameters = "InputParameters"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case organizationConfigRuleTriggerTypes = "OrganizationConfigRuleTriggerTypes"
            case policyRuntime = "PolicyRuntime"
            case policyText = "PolicyText"
            case resourceIdScope = "ResourceIdScope"
            case resourceTypesScope = "ResourceTypesScope"
            case tagKeyScope = "TagKeyScope"
            case tagValueScope = "TagValueScope"
        }
    }

    public struct OrganizationCustomPolicyRuleMetadataNoPolicy: AWSDecodableShape {
        /// A list of accounts that you can enable debug logging for your organization Config Custom Policy rule. List is null when debug logging is enabled for all accounts.
        public let debugLogDeliveryAccounts: [String]?
        /// The description that you provide for your organization Config Custom Policy rule.
        public let description: String?
        /// A string, in JSON format, that is passed to your organization Config Custom Policy rule.
        public let inputParameters: String?
        /// The maximum frequency with which Config runs evaluations for a rule. Your
        /// 			Config Custom Policy rule is triggered when Config delivers
        /// 			the configuration snapshot. For more information, see ConfigSnapshotDeliveryProperties.
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// The type of notification that triggers Config to run an evaluation for a rule.
        /// 			For Config Custom Policy rules, Config supports change
        /// 			triggered notification types:
        ///
        /// 		          ConfigurationItemChangeNotification - Triggers an evaluation when Config delivers a configuration item as a result of a resource change.    OversizedConfigurationItemChangeNotification - Triggers an evaluation when Config delivers an oversized configuration item.
        /// 				Config may generate this notification type when a resource changes and the notification exceeds the maximum size allowed by Amazon SNS.
        public let organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerTypeNoSN]?
        /// The runtime system for your organization Config Custom Policy rules. Guard is a policy-as-code language that allows you to write policies that are enforced by Config Custom Policy rules. For more information about Guard, see the Guard GitHub
        /// 			Repository.
        public let policyRuntime: String?
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let resourceIdScope: String?
        /// The type of the Amazon Web Services resource that was evaluated.
        public let resourceTypesScope: [String]?
        /// One part of a key-value pair that make up a tag. A key is a general label that acts like a category for more specific tag values.
        public let tagKeyScope: String?
        /// The optional part of a key-value pair that make up a tag. A value acts as a descriptor within a tag category (key).
        public let tagValueScope: String?

        public init(debugLogDeliveryAccounts: [String]? = nil, description: String? = nil, inputParameters: String? = nil, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerTypeNoSN]? = nil, policyRuntime: String? = nil, resourceIdScope: String? = nil, resourceTypesScope: [String]? = nil, tagKeyScope: String? = nil, tagValueScope: String? = nil) {
            self.debugLogDeliveryAccounts = debugLogDeliveryAccounts
            self.description = description
            self.inputParameters = inputParameters
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.organizationConfigRuleTriggerTypes = organizationConfigRuleTriggerTypes
            self.policyRuntime = policyRuntime
            self.resourceIdScope = resourceIdScope
            self.resourceTypesScope = resourceTypesScope
            self.tagKeyScope = tagKeyScope
            self.tagValueScope = tagValueScope
        }

        private enum CodingKeys: String, CodingKey {
            case debugLogDeliveryAccounts = "DebugLogDeliveryAccounts"
            case description = "Description"
            case inputParameters = "InputParameters"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case organizationConfigRuleTriggerTypes = "OrganizationConfigRuleTriggerTypes"
            case policyRuntime = "PolicyRuntime"
            case resourceIdScope = "ResourceIdScope"
            case resourceTypesScope = "ResourceTypesScope"
            case tagKeyScope = "TagKeyScope"
            case tagValueScope = "TagValueScope"
        }
    }

    public struct OrganizationCustomRuleMetadata: AWSEncodableShape & AWSDecodableShape {
        /// The description that you provide for your organization Config rule.
        public let description: String?
        /// A string, in JSON format, that is passed to your organization Config rule Lambda function.
        public let inputParameters: String?
        /// The lambda function ARN.
        public let lambdaFunctionArn: String
        /// The maximum frequency with which Config runs evaluations for a rule.
        /// 			Your custom rule is triggered when Config delivers the configuration snapshot. For more information, see ConfigSnapshotDeliveryProperties.
        /// 		        By default, rules with a periodic trigger are evaluated every 24 hours. To change the frequency, specify a valid
        /// 			value for the MaximumExecutionFrequency parameter.
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// The type of notification that triggers Config to run an evaluation for a rule. You can specify the following notification types:
        ///
        /// 		          ConfigurationItemChangeNotification - Triggers an evaluation when Config delivers a configuration item as a result of a resource change.    OversizedConfigurationItemChangeNotification - Triggers an evaluation when Config delivers an oversized configuration item.
        /// 			         	Config may generate this notification type when a resource changes and the notification exceeds the maximum size allowed by Amazon SNS.    ScheduledNotification - Triggers a periodic evaluation at the frequency specified for MaximumExecutionFrequency.
        public let organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerType]
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let resourceIdScope: String?
        /// The type of the Amazon Web Services resource that was evaluated.
        public let resourceTypesScope: [String]?
        /// One part of a key-value pair that make up a tag.
        /// 			A key is a general label that acts like a category for more specific tag values.
        public let tagKeyScope: String?
        /// The optional part of a key-value pair that make up a tag.
        /// 			A value acts as a descriptor within a tag category (key).
        public let tagValueScope: String?

        public init(description: String? = nil, inputParameters: String? = nil, lambdaFunctionArn: String, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, organizationConfigRuleTriggerTypes: [OrganizationConfigRuleTriggerType], resourceIdScope: String? = nil, resourceTypesScope: [String]? = nil, tagKeyScope: String? = nil, tagValueScope: String? = nil) {
            self.description = description
            self.inputParameters = inputParameters
            self.lambdaFunctionArn = lambdaFunctionArn
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.organizationConfigRuleTriggerTypes = organizationConfigRuleTriggerTypes
            self.resourceIdScope = resourceIdScope
            self.resourceTypesScope = resourceTypesScope
            self.tagKeyScope = tagKeyScope
            self.tagValueScope = tagValueScope
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, max: 2048)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, min: 1)
            try self.validate(self.lambdaFunctionArn, name: "lambdaFunctionArn", parent: name, max: 256)
            try self.validate(self.lambdaFunctionArn, name: "lambdaFunctionArn", parent: name, min: 1)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, max: 768)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, min: 1)
            try self.resourceTypesScope?.forEach {
                try validate($0, name: "resourceTypesScope[]", parent: name, max: 256)
                try validate($0, name: "resourceTypesScope[]", parent: name, min: 1)
            }
            try self.validate(self.resourceTypesScope, name: "resourceTypesScope", parent: name, max: 100)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, max: 128)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, min: 1)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, max: 256)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case inputParameters = "InputParameters"
            case lambdaFunctionArn = "LambdaFunctionArn"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case organizationConfigRuleTriggerTypes = "OrganizationConfigRuleTriggerTypes"
            case resourceIdScope = "ResourceIdScope"
            case resourceTypesScope = "ResourceTypesScope"
            case tagKeyScope = "TagKeyScope"
            case tagValueScope = "TagValueScope"
        }
    }

    public struct OrganizationManagedRuleMetadata: AWSEncodableShape & AWSDecodableShape {
        /// The description that you provide for your organization Config rule.
        public let description: String?
        /// A string, in JSON format, that is passed to your organization Config rule Lambda function.
        public let inputParameters: String?
        /// The maximum frequency with which Config runs evaluations for a rule. This is for an Config managed rule that is triggered at a periodic frequency.
        /// 		        By default, rules with a periodic trigger are evaluated every 24 hours. To change the frequency, specify a valid
        /// 			value for the MaximumExecutionFrequency parameter.
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// The ID of the Amazon Web Services resource that was evaluated.
        public let resourceIdScope: String?
        /// The type of the Amazon Web Services resource that was evaluated.
        public let resourceTypesScope: [String]?
        /// For organization config managed rules, a predefined identifier from a
        /// 			list. For example, IAM_PASSWORD_POLICY is a managed
        /// 			rule. To reference a managed rule, see Using Config managed rules.
        public let ruleIdentifier: String
        /// One part of a key-value pair that make up a tag.
        /// 			A key is a general label that acts like a category for more specific tag values.
        public let tagKeyScope: String?
        /// The optional part of a key-value pair that make up a tag.
        /// 			A value acts as a descriptor within a tag category (key).
        public let tagValueScope: String?

        public init(description: String? = nil, inputParameters: String? = nil, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, resourceIdScope: String? = nil, resourceTypesScope: [String]? = nil, ruleIdentifier: String, tagKeyScope: String? = nil, tagValueScope: String? = nil) {
            self.description = description
            self.inputParameters = inputParameters
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.resourceIdScope = resourceIdScope
            self.resourceTypesScope = resourceTypesScope
            self.ruleIdentifier = ruleIdentifier
            self.tagKeyScope = tagKeyScope
            self.tagValueScope = tagValueScope
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, max: 2048)
            try self.validate(self.inputParameters, name: "inputParameters", parent: name, min: 1)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, max: 768)
            try self.validate(self.resourceIdScope, name: "resourceIdScope", parent: name, min: 1)
            try self.resourceTypesScope?.forEach {
                try validate($0, name: "resourceTypesScope[]", parent: name, max: 256)
                try validate($0, name: "resourceTypesScope[]", parent: name, min: 1)
            }
            try self.validate(self.resourceTypesScope, name: "resourceTypesScope", parent: name, max: 100)
            try self.validate(self.ruleIdentifier, name: "ruleIdentifier", parent: name, max: 256)
            try self.validate(self.ruleIdentifier, name: "ruleIdentifier", parent: name, min: 1)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, max: 128)
            try self.validate(self.tagKeyScope, name: "tagKeyScope", parent: name, min: 1)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, max: 256)
            try self.validate(self.tagValueScope, name: "tagValueScope", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case inputParameters = "InputParameters"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case resourceIdScope = "ResourceIdScope"
            case resourceTypesScope = "ResourceTypesScope"
            case ruleIdentifier = "RuleIdentifier"
            case tagKeyScope = "TagKeyScope"
            case tagValueScope = "TagValueScope"
        }
    }

    public struct OrganizationResourceDetailedStatusFilters: AWSEncodableShape {
        /// The 12-digit account ID of the member account within an organization.
        public let accountId: String?
        /// Indicates deployment status for conformance pack in a member account.
        /// 			When management account calls PutOrganizationConformancePack action for the first time, conformance pack status is created in the member account.
        /// 			When management account calls PutOrganizationConformancePack action for the second time, conformance pack status is updated in the member account.
        /// 			Conformance pack status is deleted when the management account deletes OrganizationConformancePack and disables service access for config-multiaccountsetup.amazonaws.com.
        ///
        /// 		        Config sets the state of the conformance pack to:
        /// 		          CREATE_SUCCESSFUL when conformance pack has been created in the member account.     CREATE_IN_PROGRESS when conformance pack is being created in the member account.    CREATE_FAILED when conformance pack creation has failed in the member account.    DELETE_FAILED when conformance pack deletion has failed in the member account.    DELETE_IN_PROGRESS when conformance pack is being deleted in the member account.    DELETE_SUCCESSFUL when conformance pack has been deleted in the member account.     UPDATE_SUCCESSFUL when conformance pack has been updated in the member account.    UPDATE_IN_PROGRESS when conformance pack is being updated in the member account.    UPDATE_FAILED when conformance pack deletion has failed in the member account.
        public let status: OrganizationResourceDetailedStatus?

        public init(accountId: String? = nil, status: OrganizationResourceDetailedStatus? = nil) {
            self.accountId = accountId
            self.status = status
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case status = "Status"
        }
    }

    public struct PendingAggregationRequest: AWSDecodableShape {
        /// The 12-digit account ID of the account requesting to aggregate
        /// 			data.
        public let requesterAccountId: String?
        /// The region requesting to aggregate data.
        public let requesterAwsRegion: String?

        public init(requesterAccountId: String? = nil, requesterAwsRegion: String? = nil) {
            self.requesterAccountId = requesterAccountId
            self.requesterAwsRegion = requesterAwsRegion
        }

        private enum CodingKeys: String, CodingKey {
            case requesterAccountId = "RequesterAccountId"
            case requesterAwsRegion = "RequesterAwsRegion"
        }
    }

    public struct PutAggregationAuthorizationRequest: AWSEncodableShape {
        /// The 12-digit account ID of the account authorized to aggregate data.
        public let authorizedAccountId: String
        /// The region authorized to collect aggregated data.
        public let authorizedAwsRegion: String
        /// An array of tag object.
        public let tags: [Tag]?

        public init(authorizedAccountId: String, authorizedAwsRegion: String, tags: [Tag]? = nil) {
            self.authorizedAccountId = authorizedAccountId
            self.authorizedAwsRegion = authorizedAwsRegion
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.authorizedAccountId, name: "authorizedAccountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.authorizedAwsRegion, name: "authorizedAwsRegion", parent: name, max: 64)
            try self.validate(self.authorizedAwsRegion, name: "authorizedAwsRegion", parent: name, min: 1)
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.validate(self.tags, name: "tags", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case authorizedAccountId = "AuthorizedAccountId"
            case authorizedAwsRegion = "AuthorizedAwsRegion"
            case tags = "Tags"
        }
    }

    public struct PutAggregationAuthorizationResponse: AWSDecodableShape {
        /// Returns an AggregationAuthorization object.
        ///
        ///
        public let aggregationAuthorization: AggregationAuthorization?

        public init(aggregationAuthorization: AggregationAuthorization? = nil) {
            self.aggregationAuthorization = aggregationAuthorization
        }

        private enum CodingKeys: String, CodingKey {
            case aggregationAuthorization = "AggregationAuthorization"
        }
    }

    public struct PutConfigRuleRequest: AWSEncodableShape {
        /// The rule that you want to add to your account.
        public let configRule: ConfigRule
        /// An array of tag object.
        public let tags: [Tag]?

        public init(configRule: ConfigRule, tags: [Tag]? = nil) {
            self.configRule = configRule
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.configRule.validate(name: "\(name).configRule")
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.validate(self.tags, name: "tags", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case configRule = "ConfigRule"
            case tags = "Tags"
        }
    }

    public struct PutConfigurationAggregatorRequest: AWSEncodableShape {
        /// A list of AccountAggregationSource object.
        ///
        ///
        public let accountAggregationSources: [AccountAggregationSource]?
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// An OrganizationAggregationSource object.
        public let organizationAggregationSource: OrganizationAggregationSource?
        /// An array of tag object.
        public let tags: [Tag]?

        public init(accountAggregationSources: [AccountAggregationSource]? = nil, configurationAggregatorName: String, organizationAggregationSource: OrganizationAggregationSource? = nil, tags: [Tag]? = nil) {
            self.accountAggregationSources = accountAggregationSources
            self.configurationAggregatorName = configurationAggregatorName
            self.organizationAggregationSource = organizationAggregationSource
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.accountAggregationSources?.forEach {
                try $0.validate(name: "\(name).accountAggregationSources[]")
            }
            try self.validate(self.accountAggregationSources, name: "accountAggregationSources", parent: name, max: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.organizationAggregationSource?.validate(name: "\(name).organizationAggregationSource")
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.validate(self.tags, name: "tags", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case accountAggregationSources = "AccountAggregationSources"
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case organizationAggregationSource = "OrganizationAggregationSource"
            case tags = "Tags"
        }
    }

    public struct PutConfigurationAggregatorResponse: AWSDecodableShape {
        /// Returns a ConfigurationAggregator object.
        public let configurationAggregator: ConfigurationAggregator?

        public init(configurationAggregator: ConfigurationAggregator? = nil) {
            self.configurationAggregator = configurationAggregator
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregator = "ConfigurationAggregator"
        }
    }

    public struct PutConfigurationRecorderRequest: AWSEncodableShape {
        /// The configuration recorder object that records each
        /// 			configuration change made to the resources.
        public let configurationRecorder: ConfigurationRecorder

        public init(configurationRecorder: ConfigurationRecorder) {
            self.configurationRecorder = configurationRecorder
        }

        public func validate(name: String) throws {
            try self.configurationRecorder.validate(name: "\(name).configurationRecorder")
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorder = "ConfigurationRecorder"
        }
    }

    public struct PutConformancePackRequest: AWSEncodableShape {
        /// A list of ConformancePackInputParameter objects.
        public let conformancePackInputParameters: [ConformancePackInputParameter]?
        /// The unique name of the conformance pack you want to deploy.
        public let conformancePackName: String
        /// The name of the Amazon S3 bucket where Config stores conformance pack templates.
        /// 		        This field is optional.
        public let deliveryS3Bucket: String?
        /// The prefix for the Amazon S3 bucket.
        /// 		        This field is optional.
        public let deliveryS3KeyPrefix: String?
        /// A string containing the full conformance pack template body. The structure containing the template body has a minimum length of 1 byte and a maximum length of 51,200 bytes.
        /// 		        You can use a YAML template with two resource types: Config rule (AWS::Config::ConfigRule) and remediation action (AWS::Config::RemediationConfiguration).
        public let templateBody: String?
        /// The location of the file containing the template body (s3://bucketname/prefix). The uri must point to a conformance pack template (max size: 300 KB) that is located in an Amazon S3 bucket in the same Region as the conformance pack.
        /// 		        You must have access to read Amazon S3 bucket.
        public let templateS3Uri: String?
        /// An object of type TemplateSSMDocumentDetails, which contains the name or the Amazon Resource Name (ARN) of the Amazon Web Services Systems Manager document (SSM document) and the version of the SSM document that is used to create a conformance pack.
        public let templateSSMDocumentDetails: TemplateSSMDocumentDetails?

        public init(conformancePackInputParameters: [ConformancePackInputParameter]? = nil, conformancePackName: String, deliveryS3Bucket: String? = nil, deliveryS3KeyPrefix: String? = nil, templateBody: String? = nil, templateS3Uri: String? = nil, templateSSMDocumentDetails: TemplateSSMDocumentDetails? = nil) {
            self.conformancePackInputParameters = conformancePackInputParameters
            self.conformancePackName = conformancePackName
            self.deliveryS3Bucket = deliveryS3Bucket
            self.deliveryS3KeyPrefix = deliveryS3KeyPrefix
            self.templateBody = templateBody
            self.templateS3Uri = templateS3Uri
            self.templateSSMDocumentDetails = templateSSMDocumentDetails
        }

        public func validate(name: String) throws {
            try self.conformancePackInputParameters?.forEach {
                try $0.validate(name: "\(name).conformancePackInputParameters[]")
            }
            try self.validate(self.conformancePackInputParameters, name: "conformancePackInputParameters", parent: name, max: 60)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, max: 256)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, min: 1)
            try self.validate(self.conformancePackName, name: "conformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            try self.validate(self.deliveryS3Bucket, name: "deliveryS3Bucket", parent: name, max: 63)
            try self.validate(self.deliveryS3KeyPrefix, name: "deliveryS3KeyPrefix", parent: name, max: 1024)
            try self.validate(self.templateBody, name: "templateBody", parent: name, max: 51200)
            try self.validate(self.templateBody, name: "templateBody", parent: name, min: 1)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, max: 1024)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, min: 1)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, pattern: "^s3://")
            try self.templateSSMDocumentDetails?.validate(name: "\(name).templateSSMDocumentDetails")
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackInputParameters = "ConformancePackInputParameters"
            case conformancePackName = "ConformancePackName"
            case deliveryS3Bucket = "DeliveryS3Bucket"
            case deliveryS3KeyPrefix = "DeliveryS3KeyPrefix"
            case templateBody = "TemplateBody"
            case templateS3Uri = "TemplateS3Uri"
            case templateSSMDocumentDetails = "TemplateSSMDocumentDetails"
        }
    }

    public struct PutConformancePackResponse: AWSDecodableShape {
        /// ARN of the conformance pack.
        public let conformancePackArn: String?

        public init(conformancePackArn: String? = nil) {
            self.conformancePackArn = conformancePackArn
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackArn = "ConformancePackArn"
        }
    }

    public struct PutDeliveryChannelRequest: AWSEncodableShape {
        /// The configuration delivery channel object that delivers the
        /// 			configuration information to an Amazon S3 bucket and to an Amazon
        /// 			SNS topic.
        public let deliveryChannel: DeliveryChannel

        public init(deliveryChannel: DeliveryChannel) {
            self.deliveryChannel = deliveryChannel
        }

        public func validate(name: String) throws {
            try self.deliveryChannel.validate(name: "\(name).deliveryChannel")
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryChannel = "DeliveryChannel"
        }
    }

    public struct PutEvaluationsRequest: AWSEncodableShape {
        /// The assessments that the Lambda function performs. Each
        /// 			evaluation identifies an Amazon Web Services resource and indicates whether it
        /// 			complies with the Config rule that invokes the Lambda
        /// 			function.
        public let evaluations: [Evaluation]?
        /// An encrypted token that associates an evaluation with an Config rule. Identifies the rule and the event that triggered the
        /// 			evaluation.
        public let resultToken: String
        /// Use this parameter to specify a test run for
        /// 			PutEvaluations. You can verify whether your Lambda function will deliver evaluation results to Config. No
        /// 			updates occur to your existing evaluations, and evaluation results
        /// 			are not sent to Config.
        ///
        /// 			         When TestMode is true,
        /// 					PutEvaluations doesn't require a valid value
        /// 				for the ResultToken parameter, but the value cannot
        /// 				be null.
        ///
        public let testMode: Bool?

        public init(evaluations: [Evaluation]? = nil, resultToken: String, testMode: Bool? = nil) {
            self.evaluations = evaluations
            self.resultToken = resultToken
            self.testMode = testMode
        }

        public func validate(name: String) throws {
            try self.evaluations?.forEach {
                try $0.validate(name: "\(name).evaluations[]")
            }
            try self.validate(self.evaluations, name: "evaluations", parent: name, max: 100)
        }

        private enum CodingKeys: String, CodingKey {
            case evaluations = "Evaluations"
            case resultToken = "ResultToken"
            case testMode = "TestMode"
        }
    }

    public struct PutEvaluationsResponse: AWSDecodableShape {
        /// Requests that failed because of a client or server
        /// 			error.
        public let failedEvaluations: [Evaluation]?

        public init(failedEvaluations: [Evaluation]? = nil) {
            self.failedEvaluations = failedEvaluations
        }

        private enum CodingKeys: String, CodingKey {
            case failedEvaluations = "FailedEvaluations"
        }
    }

    public struct PutExternalEvaluationRequest: AWSEncodableShape {
        /// The name of the Config rule.
        public let configRuleName: String
        /// An ExternalEvaluation object that provides details about compliance.
        public let externalEvaluation: ExternalEvaluation

        public init(configRuleName: String, externalEvaluation: ExternalEvaluation) {
            self.configRuleName = configRuleName
            self.externalEvaluation = externalEvaluation
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.externalEvaluation.validate(name: "\(name).externalEvaluation")
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case externalEvaluation = "ExternalEvaluation"
        }
    }

    public struct PutExternalEvaluationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutOrganizationConfigRuleRequest: AWSEncodableShape {
        /// A comma-separated list of accounts that you want to exclude from an organization Config rule.
        public let excludedAccounts: [String]?
        /// The name that you assign to an organization Config rule.
        public let organizationConfigRuleName: String
        /// An OrganizationCustomPolicyRuleMetadata object. This object specifies metadata for your organization's Config Custom Policy rule. The metadata includes the runtime system in use, which accounts have debug
        /// 			logging enabled, and other custom rule metadata, such as resource type, resource ID of
        /// 			Amazon Web Services resource, and organization trigger types that initiate Config to evaluate Amazon Web Services resources against a rule.
        public let organizationCustomPolicyRuleMetadata: OrganizationCustomPolicyRuleMetadata?
        /// An OrganizationCustomRuleMetadata object. This object specifies organization custom rule metadata such as resource type,
        /// 			resource ID of Amazon Web Services resource, Lambda function ARN, and organization trigger types that trigger Config to evaluate your Amazon Web Services resources against a rule.
        /// 			It also provides the frequency with which you want Config to run evaluations for the rule if the trigger type is periodic.
        public let organizationCustomRuleMetadata: OrganizationCustomRuleMetadata?
        /// An OrganizationManagedRuleMetadata object. This object specifies organization
        /// 			managed rule metadata such as resource type and ID of Amazon Web Services resource along with the rule identifier.
        /// 			It also provides the frequency with which you want Config to run evaluations for the rule if the trigger type is periodic.
        public let organizationManagedRuleMetadata: OrganizationManagedRuleMetadata?

        public init(excludedAccounts: [String]? = nil, organizationConfigRuleName: String, organizationCustomPolicyRuleMetadata: OrganizationCustomPolicyRuleMetadata? = nil, organizationCustomRuleMetadata: OrganizationCustomRuleMetadata? = nil, organizationManagedRuleMetadata: OrganizationManagedRuleMetadata? = nil) {
            self.excludedAccounts = excludedAccounts
            self.organizationConfigRuleName = organizationConfigRuleName
            self.organizationCustomPolicyRuleMetadata = organizationCustomPolicyRuleMetadata
            self.organizationCustomRuleMetadata = organizationCustomRuleMetadata
            self.organizationManagedRuleMetadata = organizationManagedRuleMetadata
        }

        public func validate(name: String) throws {
            try self.excludedAccounts?.forEach {
                try validate($0, name: "excludedAccounts[]", parent: name, pattern: "^\\d{12}$")
            }
            try self.validate(self.excludedAccounts, name: "excludedAccounts", parent: name, max: 1000)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, max: 64)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, min: 1)
            try self.validate(self.organizationConfigRuleName, name: "organizationConfigRuleName", parent: name, pattern: "\\S")
            try self.organizationCustomPolicyRuleMetadata?.validate(name: "\(name).organizationCustomPolicyRuleMetadata")
            try self.organizationCustomRuleMetadata?.validate(name: "\(name).organizationCustomRuleMetadata")
            try self.organizationManagedRuleMetadata?.validate(name: "\(name).organizationManagedRuleMetadata")
        }

        private enum CodingKeys: String, CodingKey {
            case excludedAccounts = "ExcludedAccounts"
            case organizationConfigRuleName = "OrganizationConfigRuleName"
            case organizationCustomPolicyRuleMetadata = "OrganizationCustomPolicyRuleMetadata"
            case organizationCustomRuleMetadata = "OrganizationCustomRuleMetadata"
            case organizationManagedRuleMetadata = "OrganizationManagedRuleMetadata"
        }
    }

    public struct PutOrganizationConfigRuleResponse: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of an organization Config rule.
        public let organizationConfigRuleArn: String?

        public init(organizationConfigRuleArn: String? = nil) {
            self.organizationConfigRuleArn = organizationConfigRuleArn
        }

        private enum CodingKeys: String, CodingKey {
            case organizationConfigRuleArn = "OrganizationConfigRuleArn"
        }
    }

    public struct PutOrganizationConformancePackRequest: AWSEncodableShape {
        /// A list of ConformancePackInputParameter objects.
        public let conformancePackInputParameters: [ConformancePackInputParameter]?
        /// The name of the Amazon S3 bucket where Config stores conformance pack templates.
        /// 		        This field is optional. If used, it must be prefixed with awsconfigconforms.
        public let deliveryS3Bucket: String?
        /// The prefix for the Amazon S3 bucket.
        /// 		        This field is optional.
        public let deliveryS3KeyPrefix: String?
        /// A list of Amazon Web Services accounts to be excluded from an organization conformance pack while deploying a conformance pack.
        public let excludedAccounts: [String]?
        /// Name of the organization conformance pack you want to create.
        public let organizationConformancePackName: String
        /// A string containing full conformance pack template body. Structure containing the template body
        /// 			with a minimum length of 1 byte and a maximum length of 51,200 bytes.
        public let templateBody: String?
        /// Location of file containing the template body. The uri must point to the conformance pack template
        /// 			(max size: 300 KB).
        /// 		        You must have access to read Amazon S3 bucket.
        public let templateS3Uri: String?

        public init(conformancePackInputParameters: [ConformancePackInputParameter]? = nil, deliveryS3Bucket: String? = nil, deliveryS3KeyPrefix: String? = nil, excludedAccounts: [String]? = nil, organizationConformancePackName: String, templateBody: String? = nil, templateS3Uri: String? = nil) {
            self.conformancePackInputParameters = conformancePackInputParameters
            self.deliveryS3Bucket = deliveryS3Bucket
            self.deliveryS3KeyPrefix = deliveryS3KeyPrefix
            self.excludedAccounts = excludedAccounts
            self.organizationConformancePackName = organizationConformancePackName
            self.templateBody = templateBody
            self.templateS3Uri = templateS3Uri
        }

        public func validate(name: String) throws {
            try self.conformancePackInputParameters?.forEach {
                try $0.validate(name: "\(name).conformancePackInputParameters[]")
            }
            try self.validate(self.conformancePackInputParameters, name: "conformancePackInputParameters", parent: name, max: 60)
            try self.validate(self.deliveryS3Bucket, name: "deliveryS3Bucket", parent: name, max: 63)
            try self.validate(self.deliveryS3KeyPrefix, name: "deliveryS3KeyPrefix", parent: name, max: 1024)
            try self.excludedAccounts?.forEach {
                try validate($0, name: "excludedAccounts[]", parent: name, pattern: "^\\d{12}$")
            }
            try self.validate(self.excludedAccounts, name: "excludedAccounts", parent: name, max: 1000)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, max: 128)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, min: 1)
            try self.validate(self.organizationConformancePackName, name: "organizationConformancePackName", parent: name, pattern: "^[a-zA-Z][-a-zA-Z0-9]*$")
            try self.validate(self.templateBody, name: "templateBody", parent: name, max: 51200)
            try self.validate(self.templateBody, name: "templateBody", parent: name, min: 1)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, max: 1024)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, min: 1)
            try self.validate(self.templateS3Uri, name: "templateS3Uri", parent: name, pattern: "^s3://")
        }

        private enum CodingKeys: String, CodingKey {
            case conformancePackInputParameters = "ConformancePackInputParameters"
            case deliveryS3Bucket = "DeliveryS3Bucket"
            case deliveryS3KeyPrefix = "DeliveryS3KeyPrefix"
            case excludedAccounts = "ExcludedAccounts"
            case organizationConformancePackName = "OrganizationConformancePackName"
            case templateBody = "TemplateBody"
            case templateS3Uri = "TemplateS3Uri"
        }
    }

    public struct PutOrganizationConformancePackResponse: AWSDecodableShape {
        /// ARN of the organization conformance pack.
        public let organizationConformancePackArn: String?

        public init(organizationConformancePackArn: String? = nil) {
            self.organizationConformancePackArn = organizationConformancePackArn
        }

        private enum CodingKeys: String, CodingKey {
            case organizationConformancePackArn = "OrganizationConformancePackArn"
        }
    }

    public struct PutRemediationConfigurationsRequest: AWSEncodableShape {
        /// A list of remediation configuration objects.
        public let remediationConfigurations: [RemediationConfiguration]

        public init(remediationConfigurations: [RemediationConfiguration]) {
            self.remediationConfigurations = remediationConfigurations
        }

        public func validate(name: String) throws {
            try self.remediationConfigurations.forEach {
                try $0.validate(name: "\(name).remediationConfigurations[]")
            }
            try self.validate(self.remediationConfigurations, name: "remediationConfigurations", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case remediationConfigurations = "RemediationConfigurations"
        }
    }

    public struct PutRemediationConfigurationsResponse: AWSDecodableShape {
        /// Returns a list of failed remediation batch objects.
        public let failedBatches: [FailedRemediationBatch]?

        public init(failedBatches: [FailedRemediationBatch]? = nil) {
            self.failedBatches = failedBatches
        }

        private enum CodingKeys: String, CodingKey {
            case failedBatches = "FailedBatches"
        }
    }

    public struct PutRemediationExceptionsRequest: AWSEncodableShape {
        /// The name of the Config rule for which you want to create remediation exception.
        public let configRuleName: String
        /// The exception is automatically deleted after the expiration date.
        public let expirationTime: Date?
        /// The message contains an explanation of the exception.
        public let message: String?
        /// An exception list of resource exception keys to be processed with the current request. Config adds exception for each resource key. For example, Config adds 3 exceptions for 3 resource keys.
        public let resourceKeys: [RemediationExceptionResourceKey]

        public init(configRuleName: String, expirationTime: Date? = nil, message: String? = nil, resourceKeys: [RemediationExceptionResourceKey]) {
            self.configRuleName = configRuleName
            self.expirationTime = expirationTime
            self.message = message
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.message, name: "message", parent: name, max: 1024)
            try self.validate(self.message, name: "message", parent: name, min: 1)
            try self.resourceKeys.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case expirationTime = "ExpirationTime"
            case message = "Message"
            case resourceKeys = "ResourceKeys"
        }
    }

    public struct PutRemediationExceptionsResponse: AWSDecodableShape {
        /// Returns a list of failed remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.
        public let failedBatches: [FailedRemediationExceptionBatch]?

        public init(failedBatches: [FailedRemediationExceptionBatch]? = nil) {
            self.failedBatches = failedBatches
        }

        private enum CodingKeys: String, CodingKey {
            case failedBatches = "FailedBatches"
        }
    }

    public struct PutResourceConfigRequest: AWSEncodableShape {
        /// The configuration object of the resource in valid JSON format. It must match the schema registered with CloudFormation.
        /// 		        The configuration JSON must not exceed 64 KB.
        public let configuration: String
        /// Unique identifier of the resource.
        public let resourceId: String
        /// Name of the resource.
        public let resourceName: String?
        /// The type of the resource. The custom resource type must be registered with CloudFormation.
        /// 		        You cannot use the organization names “amzn”, “amazon”, “alexa”, “custom” with custom resource types. It is the first part of the ResourceType up to the first ::.
        public let resourceType: String
        /// Version of the schema registered for the ResourceType in CloudFormation.
        public let schemaVersionId: String
        /// Tags associated with the resource.
        /// 		        This field is not to be confused with the Amazon Web Services-wide tag feature for Amazon Web Services resources.
        /// 			Tags for PutResourceConfig are tags that you supply for the configuration items of your custom resources.
        public let tags: [String: String]?

        public init(configuration: String, resourceId: String, resourceName: String? = nil, resourceType: String, schemaVersionId: String, tags: [String: String]? = nil) {
            self.configuration = configuration
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
            self.schemaVersionId = schemaVersionId
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 196)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
            try self.validate(self.schemaVersionId, name: "schemaVersionId", parent: name, max: 128)
            try self.validate(self.schemaVersionId, name: "schemaVersionId", parent: name, min: 1)
            try self.validate(self.schemaVersionId, name: "schemaVersionId", parent: name, pattern: "^[A-Za-z0-9-]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case configuration = "Configuration"
            case resourceId = "ResourceId"
            case resourceName = "ResourceName"
            case resourceType = "ResourceType"
            case schemaVersionId = "SchemaVersionId"
            case tags = "Tags"
        }
    }

    public struct PutRetentionConfigurationRequest: AWSEncodableShape {
        /// Number of days Config stores your historical
        /// 			information.
        ///
        /// 			         Currently, only applicable to the configuration item
        /// 				history.
        ///
        public let retentionPeriodInDays: Int

        public init(retentionPeriodInDays: Int = 0) {
            self.retentionPeriodInDays = retentionPeriodInDays
        }

        public func validate(name: String) throws {
            try self.validate(self.retentionPeriodInDays, name: "retentionPeriodInDays", parent: name, max: 2557)
            try self.validate(self.retentionPeriodInDays, name: "retentionPeriodInDays", parent: name, min: 30)
        }

        private enum CodingKeys: String, CodingKey {
            case retentionPeriodInDays = "RetentionPeriodInDays"
        }
    }

    public struct PutRetentionConfigurationResponse: AWSDecodableShape {
        /// Returns a retention configuration object.
        public let retentionConfiguration: RetentionConfiguration?

        public init(retentionConfiguration: RetentionConfiguration? = nil) {
            self.retentionConfiguration = retentionConfiguration
        }

        private enum CodingKeys: String, CodingKey {
            case retentionConfiguration = "RetentionConfiguration"
        }
    }

    public struct PutStoredQueryRequest: AWSEncodableShape {
        /// A list of StoredQuery objects.
        /// 			The mandatory fields are QueryName and Expression.
        /// 		        When you are creating a query, you must provide a query name and an expression.
        /// 			When you are updating a query, you must provide a query name but updating the description is optional.
        public let storedQuery: StoredQuery
        /// A list of Tags object.
        public let tags: [Tag]?

        public init(storedQuery: StoredQuery, tags: [Tag]? = nil) {
            self.storedQuery = storedQuery
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.storedQuery.validate(name: "\(name).storedQuery")
            try self.tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.validate(self.tags, name: "tags", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case storedQuery = "StoredQuery"
            case tags = "Tags"
        }
    }

    public struct PutStoredQueryResponse: AWSDecodableShape {
        /// Amazon Resource Name (ARN) of the query.
        /// 			For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.
        public let queryArn: String?

        public init(queryArn: String? = nil) {
            self.queryArn = queryArn
        }

        private enum CodingKeys: String, CodingKey {
            case queryArn = "QueryArn"
        }
    }

    public struct QueryInfo: AWSDecodableShape {
        /// Returns a FieldInfo object.
        public let selectFields: [FieldInfo]?

        public init(selectFields: [FieldInfo]? = nil) {
            self.selectFields = selectFields
        }

        private enum CodingKeys: String, CodingKey {
            case selectFields = "SelectFields"
        }
    }

    public struct RecordingGroup: AWSEncodableShape & AWSDecodableShape {
        /// Specifies whether Config records configuration changes for
        /// 			every supported type of regional resource.
        /// 		       If you set this option to true, when Config
        /// 			adds support for a new type of regional resource, it starts
        /// 			recording resources of that type automatically.
        /// 		       If you set this option to true, you cannot
        /// 			enumerate a list of resourceTypes.
        public let allSupported: Bool?
        /// Specifies whether Config includes all supported types of
        /// 			global resources (for example, IAM resources) with the resources
        /// 			that it records.
        /// 		       Before you can set this option to true, you must
        /// 			set the allSupported option to
        /// 			true.
        /// 		       If you set this option to true, when Config
        /// 			adds support for a new type of global resource, it starts recording
        /// 			resources of that type automatically.
        /// 		       The configuration details for any global resource are the same
        /// 			in all regions. To prevent duplicate configuration items, you should
        /// 			consider customizing Config in only one region to record global
        /// 			resources.
        public let includeGlobalResourceTypes: Bool?
        /// A comma-separated list that specifies the types of Amazon Web Services
        /// 			resources for which Config records configuration changes (for
        /// 			example, AWS::EC2::Instance or
        /// 				AWS::CloudTrail::Trail).
        /// 		       To record all configuration changes, you must
        /// 			set the allSupported option to
        /// 			true.
        /// 		       If you set this option to false, when Config
        /// 			adds support for a new type of resource, it will not record
        /// 			resources of that type unless you manually add that type to your
        /// 			recording group.
        /// 		       For a list of valid resourceTypes values, see the
        /// 				resourceType Value column in
        /// 				Supported Amazon Web Services resource Types.
        public let resourceTypes: [ResourceType]?

        public init(allSupported: Bool? = nil, includeGlobalResourceTypes: Bool? = nil, resourceTypes: [ResourceType]? = nil) {
            self.allSupported = allSupported
            self.includeGlobalResourceTypes = includeGlobalResourceTypes
            self.resourceTypes = resourceTypes
        }

        private enum CodingKeys: String, CodingKey {
            case allSupported
            case includeGlobalResourceTypes
            case resourceTypes
        }
    }

    public struct Relationship: AWSDecodableShape {
        /// The type of relationship with the related resource.
        public let relationshipName: String?
        /// The ID of the related resource (for example,
        /// 				sg-xxxxxx).
        public let resourceId: String?
        /// The custom name of the related resource, if
        /// 			available.
        public let resourceName: String?
        /// The resource type of the related resource.
        public let resourceType: ResourceType?

        public init(relationshipName: String? = nil, resourceId: String? = nil, resourceName: String? = nil, resourceType: ResourceType? = nil) {
            self.relationshipName = relationshipName
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case relationshipName
            case resourceId
            case resourceName
            case resourceType
        }
    }

    public struct RemediationConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// Amazon Resource Name (ARN) of remediation configuration.
        public let arn: String?
        /// The remediation is triggered automatically.
        public let automatic: Bool?
        /// The name of the Config rule.
        public let configRuleName: String
        /// Name of the service that owns the service-linked rule, if applicable.
        public let createdByService: String?
        /// An ExecutionControls object.
        public let executionControls: ExecutionControls?
        /// The maximum number of failed attempts for auto-remediation. If you do not select a number, the default is 5.
        /// 		       For example, if you specify MaximumAutomaticAttempts as 5 with RetryAttemptSeconds as 50 seconds,
        ///
        /// 			Config will put a RemediationException on your behalf for the failing resource after the 5th failed attempt within 50 seconds.
        public let maximumAutomaticAttempts: Int?
        /// An object of the RemediationParameterValue.
        public let parameters: [String: RemediationParameterValue]?
        /// The type of a resource.
        public let resourceType: String?
        /// Maximum time in seconds that Config runs auto-remediation. If you do not select a number, the default is 60 seconds.
        /// 		       For example, if you specify RetryAttemptSeconds as 50 seconds and MaximumAutomaticAttempts as 5,
        /// 		Config will run auto-remediations 5 times within 50 seconds before throwing an exception.
        public let retryAttemptSeconds: Int64?
        /// Target ID is the name of the public document.
        public let targetId: String
        /// The type of the target. Target executes remediation. For example, SSM document.
        public let targetType: RemediationTargetType
        /// Version of the target. For example, version of the SSM document.
        /// 		        If you make backward incompatible changes to the SSM document,
        /// 			you must call PutRemediationConfiguration API again to ensure the remediations can run.
        public let targetVersion: String?

        public init(arn: String? = nil, automatic: Bool? = nil, configRuleName: String, createdByService: String? = nil, executionControls: ExecutionControls? = nil, maximumAutomaticAttempts: Int? = nil, parameters: [String: RemediationParameterValue]? = nil, resourceType: String? = nil, retryAttemptSeconds: Int64? = nil, targetId: String, targetType: RemediationTargetType, targetVersion: String? = nil) {
            self.arn = arn
            self.automatic = automatic
            self.configRuleName = configRuleName
            self.createdByService = createdByService
            self.executionControls = executionControls
            self.maximumAutomaticAttempts = maximumAutomaticAttempts
            self.parameters = parameters
            self.resourceType = resourceType
            self.retryAttemptSeconds = retryAttemptSeconds
            self.targetId = targetId
            self.targetType = targetType
            self.targetVersion = targetVersion
        }

        public func validate(name: String) throws {
            try self.validate(self.arn, name: "arn", parent: name, max: 1024)
            try self.validate(self.arn, name: "arn", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.validate(self.createdByService, name: "createdByService", parent: name, max: 1024)
            try self.validate(self.createdByService, name: "createdByService", parent: name, min: 1)
            try self.executionControls?.validate(name: "\(name).executionControls")
            try self.validate(self.maximumAutomaticAttempts, name: "maximumAutomaticAttempts", parent: name, max: 25)
            try self.validate(self.maximumAutomaticAttempts, name: "maximumAutomaticAttempts", parent: name, min: 1)
            try self.parameters?.forEach {
                try validate($0.key, name: "parameters.key", parent: name, max: 256)
                try validate($0.key, name: "parameters.key", parent: name, min: 1)
                try $0.value.validate(name: "\(name).parameters[\"\($0.key)\"]")
            }
            try self.validate(self.parameters, name: "parameters", parent: name, max: 25)
            try self.validate(self.retryAttemptSeconds, name: "retryAttemptSeconds", parent: name, max: 2_678_000)
            try self.validate(self.retryAttemptSeconds, name: "retryAttemptSeconds", parent: name, min: 1)
            try self.validate(self.targetId, name: "targetId", parent: name, max: 256)
            try self.validate(self.targetId, name: "targetId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case arn = "Arn"
            case automatic = "Automatic"
            case configRuleName = "ConfigRuleName"
            case createdByService = "CreatedByService"
            case executionControls = "ExecutionControls"
            case maximumAutomaticAttempts = "MaximumAutomaticAttempts"
            case parameters = "Parameters"
            case resourceType = "ResourceType"
            case retryAttemptSeconds = "RetryAttemptSeconds"
            case targetId = "TargetId"
            case targetType = "TargetType"
            case targetVersion = "TargetVersion"
        }
    }

    public struct RemediationException: AWSDecodableShape {
        /// The name of the Config rule.
        public let configRuleName: String
        /// The time when the remediation exception will be deleted.
        public let expirationTime: Date?
        /// An explanation of an remediation exception.
        public let message: String?
        /// The ID of the resource (for example., sg-xxxxxx).
        public let resourceId: String
        /// The type of a resource.
        public let resourceType: String

        public init(configRuleName: String, expirationTime: Date? = nil, message: String? = nil, resourceId: String, resourceType: String) {
            self.configRuleName = configRuleName
            self.expirationTime = expirationTime
            self.message = message
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case expirationTime = "ExpirationTime"
            case message = "Message"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct RemediationExceptionResourceKey: AWSEncodableShape & AWSDecodableShape {
        /// The ID of the resource (for example., sg-xxxxxx).
        public let resourceId: String?
        /// The type of a resource.
        public let resourceType: String?

        public init(resourceId: String? = nil, resourceType: String? = nil) {
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 1024)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 256)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct RemediationExecutionStatus: AWSDecodableShape {
        /// Start time when the remediation was executed.
        public let invocationTime: Date?
        /// The time when the remediation execution was last updated.
        public let lastUpdatedTime: Date?
        public let resourceKey: ResourceKey?
        /// ENUM of the values.
        public let state: RemediationExecutionState?
        /// Details of every step.
        public let stepDetails: [RemediationExecutionStep]?

        public init(invocationTime: Date? = nil, lastUpdatedTime: Date? = nil, resourceKey: ResourceKey? = nil, state: RemediationExecutionState? = nil, stepDetails: [RemediationExecutionStep]? = nil) {
            self.invocationTime = invocationTime
            self.lastUpdatedTime = lastUpdatedTime
            self.resourceKey = resourceKey
            self.state = state
            self.stepDetails = stepDetails
        }

        private enum CodingKeys: String, CodingKey {
            case invocationTime = "InvocationTime"
            case lastUpdatedTime = "LastUpdatedTime"
            case resourceKey = "ResourceKey"
            case state = "State"
            case stepDetails = "StepDetails"
        }
    }

    public struct RemediationExecutionStep: AWSDecodableShape {
        /// An error message if the step was interrupted during execution.
        public let errorMessage: String?
        /// The details of the step.
        public let name: String?
        /// The time when the step started.
        public let startTime: Date?
        /// The valid status of the step.
        public let state: RemediationExecutionStepState?
        /// The time when the step stopped.
        public let stopTime: Date?

        public init(errorMessage: String? = nil, name: String? = nil, startTime: Date? = nil, state: RemediationExecutionStepState? = nil, stopTime: Date? = nil) {
            self.errorMessage = errorMessage
            self.name = name
            self.startTime = startTime
            self.state = state
            self.stopTime = stopTime
        }

        private enum CodingKeys: String, CodingKey {
            case errorMessage = "ErrorMessage"
            case name = "Name"
            case startTime = "StartTime"
            case state = "State"
            case stopTime = "StopTime"
        }
    }

    public struct RemediationParameterValue: AWSEncodableShape & AWSDecodableShape {
        /// The value is dynamic and changes at run-time.
        public let resourceValue: ResourceValue?
        /// The value is static and does not change at run-time.
        public let staticValue: StaticValue?

        public init(resourceValue: ResourceValue? = nil, staticValue: StaticValue? = nil) {
            self.resourceValue = resourceValue
            self.staticValue = staticValue
        }

        public func validate(name: String) throws {
            try self.staticValue?.validate(name: "\(name).staticValue")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceValue = "ResourceValue"
            case staticValue = "StaticValue"
        }
    }

    public struct ResourceCount: AWSDecodableShape {
        /// The number of resources.
        public let count: Int64?
        /// The resource type (for example,
        /// 				"AWS::EC2::Instance").
        public let resourceType: ResourceType?

        public init(count: Int64? = nil, resourceType: ResourceType? = nil) {
            self.count = count
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case count
            case resourceType
        }
    }

    public struct ResourceCountFilters: AWSEncodableShape {
        /// The 12-digit ID of the account.
        public let accountId: String?
        /// The region where the account is located.
        public let region: String?
        /// The type of the Amazon Web Services resource.
        public let resourceType: ResourceType?

        public init(accountId: String? = nil, region: String? = nil, resourceType: ResourceType? = nil) {
            self.accountId = accountId
            self.region = region
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.region, name: "region", parent: name, max: 64)
            try self.validate(self.region, name: "region", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case region = "Region"
            case resourceType = "ResourceType"
        }
    }

    public struct ResourceDetails: AWSEncodableShape & AWSDecodableShape {
        /// The resource definition to be evaluated as per the resource configuration schema type.
        public let resourceConfiguration: String
        /// The schema type of the resource configuration.
        public let resourceConfigurationSchemaType: ResourceConfigurationSchemaType?
        /// A unique resource ID for an evaluation.
        public let resourceId: String
        /// The type of resource being evaluated.
        public let resourceType: String

        public init(resourceConfiguration: String, resourceConfigurationSchemaType: ResourceConfigurationSchemaType? = nil, resourceId: String, resourceType: String) {
            self.resourceConfiguration = resourceConfiguration
            self.resourceConfigurationSchemaType = resourceConfigurationSchemaType
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceConfiguration, name: "resourceConfiguration", parent: name, max: 51200)
            try self.validate(self.resourceConfiguration, name: "resourceConfiguration", parent: name, min: 1)
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
            try self.validate(self.resourceType, name: "resourceType", parent: name, max: 256)
            try self.validate(self.resourceType, name: "resourceType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceConfiguration = "ResourceConfiguration"
            case resourceConfigurationSchemaType = "ResourceConfigurationSchemaType"
            case resourceId = "ResourceId"
            case resourceType = "ResourceType"
        }
    }

    public struct ResourceEvaluation: AWSDecodableShape {
        /// The mode of an evaluation. The valid values are Detective or Proactive.
        public let evaluationMode: EvaluationMode?
        /// The starting time of an execution.
        public let evaluationStartTimestamp: Date?
        /// The ResourceEvaluationId of a evaluation.
        public let resourceEvaluationId: String?

        public init(evaluationMode: EvaluationMode? = nil, evaluationStartTimestamp: Date? = nil, resourceEvaluationId: String? = nil) {
            self.evaluationMode = evaluationMode
            self.evaluationStartTimestamp = evaluationStartTimestamp
            self.resourceEvaluationId = resourceEvaluationId
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationMode = "EvaluationMode"
            case evaluationStartTimestamp = "EvaluationStartTimestamp"
            case resourceEvaluationId = "ResourceEvaluationId"
        }
    }

    public struct ResourceEvaluationFilters: AWSEncodableShape {
        /// Filters evaluations for a given infrastructure deployment. For example: CFN Stack.
        public let evaluationContextIdentifier: String?
        /// Filters all resource evaluations results based on an evaluation mode. the valid value for this API is Proactive.
        public let evaluationMode: EvaluationMode?
        /// Returns a TimeWindow object.
        public let timeWindow: TimeWindow?

        public init(evaluationContextIdentifier: String? = nil, evaluationMode: EvaluationMode? = nil, timeWindow: TimeWindow? = nil) {
            self.evaluationContextIdentifier = evaluationContextIdentifier
            self.evaluationMode = evaluationMode
            self.timeWindow = timeWindow
        }

        public func validate(name: String) throws {
            try self.validate(self.evaluationContextIdentifier, name: "evaluationContextIdentifier", parent: name, max: 128)
            try self.validate(self.evaluationContextIdentifier, name: "evaluationContextIdentifier", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case evaluationContextIdentifier = "EvaluationContextIdentifier"
            case evaluationMode = "EvaluationMode"
            case timeWindow = "TimeWindow"
        }
    }

    public struct ResourceFilters: AWSEncodableShape {
        /// The 12-digit source account ID.
        public let accountId: String?
        /// The source region.
        public let region: String?
        /// The ID of the resource.
        public let resourceId: String?
        /// The name of the resource.
        public let resourceName: String?

        public init(accountId: String? = nil, region: String? = nil, resourceId: String? = nil, resourceName: String? = nil) {
            self.accountId = accountId
            self.region = region
            self.resourceId = resourceId
            self.resourceName = resourceName
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.region, name: "region", parent: name, max: 64)
            try self.validate(self.region, name: "region", parent: name, min: 1)
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case region = "Region"
            case resourceId = "ResourceId"
            case resourceName = "ResourceName"
        }
    }

    public struct ResourceIdentifier: AWSDecodableShape {
        /// The time that the resource was deleted.
        public let resourceDeletionTime: Date?
        /// The ID of the resource (for example,
        /// 			sg-xxxxxx).
        public let resourceId: String?
        /// The custom name of the resource (if available).
        public let resourceName: String?
        /// The type of resource.
        public let resourceType: ResourceType?

        public init(resourceDeletionTime: Date? = nil, resourceId: String? = nil, resourceName: String? = nil, resourceType: ResourceType? = nil) {
            self.resourceDeletionTime = resourceDeletionTime
            self.resourceId = resourceId
            self.resourceName = resourceName
            self.resourceType = resourceType
        }

        private enum CodingKeys: String, CodingKey {
            case resourceDeletionTime
            case resourceId
            case resourceName
            case resourceType
        }
    }

    public struct ResourceKey: AWSEncodableShape & AWSDecodableShape {
        /// The ID of the resource (for example., sg-xxxxxx).
        public let resourceId: String
        /// The resource type.
        public let resourceType: ResourceType

        public init(resourceId: String, resourceType: ResourceType) {
            self.resourceId = resourceId
            self.resourceType = resourceType
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceId, name: "resourceId", parent: name, max: 768)
            try self.validate(self.resourceId, name: "resourceId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceId
            case resourceType
        }
    }

    public struct ResourceValue: AWSEncodableShape & AWSDecodableShape {
        /// The value is a resource ID.
        public let value: ResourceValueType

        public init(value: ResourceValueType) {
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case value = "Value"
        }
    }

    public struct RetentionConfiguration: AWSDecodableShape {
        /// The name of the retention configuration object.
        public let name: String
        /// Number of days Config stores your historical information.
        /// 		        Currently, only applicable to the configuration item history.
        public let retentionPeriodInDays: Int

        public init(name: String, retentionPeriodInDays: Int) {
            self.name = name
            self.retentionPeriodInDays = retentionPeriodInDays
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case retentionPeriodInDays = "RetentionPeriodInDays"
        }
    }

    public struct Scope: AWSEncodableShape & AWSDecodableShape {
        /// The ID of the only Amazon Web Services resource that you want to trigger an
        /// 			evaluation for the rule. If you specify a resource ID, you must
        /// 			specify one resource type for
        /// 			ComplianceResourceTypes.
        public let complianceResourceId: String?
        /// The resource types of only those Amazon Web Services resources that you want to
        /// 			trigger an evaluation for the rule. You can only specify one type if
        /// 			you also specify a resource ID for
        /// 			ComplianceResourceId.
        public let complianceResourceTypes: [String]?
        /// The tag key that is applied to only those Amazon Web Services resources that
        /// 			you want to trigger an evaluation for the rule.
        public let tagKey: String?
        /// The tag value applied to only those Amazon Web Services resources that you want
        /// 			to trigger an evaluation for the rule. If you specify a value for
        /// 				TagValue, you must also specify a value for
        /// 				TagKey.
        public let tagValue: String?

        public init(complianceResourceId: String? = nil, complianceResourceTypes: [String]? = nil, tagKey: String? = nil, tagValue: String? = nil) {
            self.complianceResourceId = complianceResourceId
            self.complianceResourceTypes = complianceResourceTypes
            self.tagKey = tagKey
            self.tagValue = tagValue
        }

        public func validate(name: String) throws {
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, max: 768)
            try self.validate(self.complianceResourceId, name: "complianceResourceId", parent: name, min: 1)
            try self.complianceResourceTypes?.forEach {
                try validate($0, name: "complianceResourceTypes[]", parent: name, max: 256)
                try validate($0, name: "complianceResourceTypes[]", parent: name, min: 1)
            }
            try self.validate(self.complianceResourceTypes, name: "complianceResourceTypes", parent: name, max: 100)
            try self.validate(self.tagKey, name: "tagKey", parent: name, max: 128)
            try self.validate(self.tagKey, name: "tagKey", parent: name, min: 1)
            try self.validate(self.tagValue, name: "tagValue", parent: name, max: 256)
            try self.validate(self.tagValue, name: "tagValue", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case complianceResourceId = "ComplianceResourceId"
            case complianceResourceTypes = "ComplianceResourceTypes"
            case tagKey = "TagKey"
            case tagValue = "TagValue"
        }
    }

    public struct SelectAggregateResourceConfigRequest: AWSEncodableShape {
        /// The name of the configuration aggregator.
        public let configurationAggregatorName: String
        /// The SQL query SELECT command.
        public let expression: String
        /// The maximum number of query results returned on each page.
        public let limit: Int?
        /// The maximum number of query results returned on each page. Config also allows the Limit request parameter.
        public let maxResults: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(configurationAggregatorName: String, expression: String, limit: Int? = nil, maxResults: Int? = nil, nextToken: String? = nil) {
            self.configurationAggregatorName = configurationAggregatorName
            self.expression = expression
            self.limit = limit
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, max: 256)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, min: 1)
            try self.validate(self.configurationAggregatorName, name: "configurationAggregatorName", parent: name, pattern: "^[\\w\\-]+$")
            try self.validate(self.expression, name: "expression", parent: name, max: 4096)
            try self.validate(self.expression, name: "expression", parent: name, min: 1)
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationAggregatorName = "ConfigurationAggregatorName"
            case expression = "Expression"
            case limit = "Limit"
            case maxResults = "MaxResults"
            case nextToken = "NextToken"
        }
    }

    public struct SelectAggregateResourceConfigResponse: AWSDecodableShape {
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?
        public let queryInfo: QueryInfo?
        /// Returns the results for the SQL query.
        public let results: [String]?

        public init(nextToken: String? = nil, queryInfo: QueryInfo? = nil, results: [String]? = nil) {
            self.nextToken = nextToken
            self.queryInfo = queryInfo
            self.results = results
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case queryInfo = "QueryInfo"
            case results = "Results"
        }
    }

    public struct SelectResourceConfigRequest: AWSEncodableShape {
        /// The SQL query SELECT command.
        public let expression: String
        /// The maximum number of query results returned on each page.
        public let limit: Int?
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?

        public init(expression: String, limit: Int? = nil, nextToken: String? = nil) {
            self.expression = expression
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.expression, name: "expression", parent: name, max: 4096)
            try self.validate(self.expression, name: "expression", parent: name, min: 1)
            try self.validate(self.limit, name: "limit", parent: name, max: 100)
            try self.validate(self.limit, name: "limit", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case expression = "Expression"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct SelectResourceConfigResponse: AWSDecodableShape {
        /// The nextToken string returned in a previous request that you use to request the next page of results in a paginated response.
        public let nextToken: String?
        /// Returns the QueryInfo object.
        public let queryInfo: QueryInfo?
        /// Returns the results for the SQL query.
        public let results: [String]?

        public init(nextToken: String? = nil, queryInfo: QueryInfo? = nil, results: [String]? = nil) {
            self.nextToken = nextToken
            self.queryInfo = queryInfo
            self.results = results
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case queryInfo = "QueryInfo"
            case results = "Results"
        }
    }

    public struct Source: AWSEncodableShape & AWSDecodableShape {
        /// Provides the runtime system, policy definition, and whether debug logging is enabled. Required when owner is set to CUSTOM_POLICY.
        public let customPolicyDetails: CustomPolicyDetails?
        /// Indicates whether Amazon Web Services or the customer owns and manages the Config rule.
        ///
        /// 		       Config Managed Rules are predefined rules owned by Amazon Web Services. For more information, see Config Managed Rules in the Config developer guide.
        ///
        /// 		       Config Custom Rules are rules that you can develop either with Guard (CUSTOM_POLICY) or Lambda (CUSTOM_LAMBDA). For more information, see Config Custom Rules  in the Config developer guide.
        public let owner: Owner
        /// Provides the source and the message types that cause Config to evaluate your Amazon Web Services resources against a rule. It also provides the frequency with which you want Config to run evaluations for the rule if the trigger type is periodic.
        ///
        /// 		       If the owner is set to CUSTOM_POLICY, the only acceptable values for the Config rule trigger message type are ConfigurationItemChangeNotification and OversizedConfigurationItemChangeNotification.
        public let sourceDetails: [SourceDetail]?
        /// For Config Managed rules, a predefined identifier from a
        /// 			list. For example, IAM_PASSWORD_POLICY is a managed
        /// 			rule. To reference a managed rule, see List of Config Managed Rules.
        /// 		       For Config Custom Lambda rules, the identifier is the Amazon Resource Name
        /// 			(ARN) of the rule's Lambda function, such as
        /// 			arn:aws:lambda:us-east-2:123456789012:function:custom_rule_name.
        ///
        /// 		       For Config Custom Policy rules, this field will be ignored.
        public let sourceIdentifier: String?

        public init(customPolicyDetails: CustomPolicyDetails? = nil, owner: Owner, sourceDetails: [SourceDetail]? = nil, sourceIdentifier: String? = nil) {
            self.customPolicyDetails = customPolicyDetails
            self.owner = owner
            self.sourceDetails = sourceDetails
            self.sourceIdentifier = sourceIdentifier
        }

        public func validate(name: String) throws {
            try self.customPolicyDetails?.validate(name: "\(name).customPolicyDetails")
            try self.validate(self.sourceDetails, name: "sourceDetails", parent: name, max: 25)
            try self.validate(self.sourceIdentifier, name: "sourceIdentifier", parent: name, max: 256)
            try self.validate(self.sourceIdentifier, name: "sourceIdentifier", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case customPolicyDetails = "CustomPolicyDetails"
            case owner = "Owner"
            case sourceDetails = "SourceDetails"
            case sourceIdentifier = "SourceIdentifier"
        }
    }

    public struct SourceDetail: AWSEncodableShape & AWSDecodableShape {
        /// The source of the event, such as an Amazon Web Services service, that triggers
        /// 			Config to evaluate your Amazon Web Services resources.
        public let eventSource: EventSource?
        /// The frequency at which you want Config to run evaluations
        /// 			for a custom rule with a periodic trigger. If you specify a value
        /// 			for MaximumExecutionFrequency, then
        /// 				MessageType must use the
        /// 				ScheduledNotification value.
        ///
        ///
        /// 			         By default, rules with a periodic trigger are evaluated
        /// 				every 24 hours. To change the frequency, specify a valid value
        /// 				for the MaximumExecutionFrequency
        /// 				parameter.
        /// 			         Based on the valid value you choose, Config runs
        /// 				evaluations once for each valid value. For example, if you
        /// 				choose Three_Hours, Config runs evaluations
        /// 				once every three hours. In this case, Three_Hours
        /// 				is the frequency of this rule.
        ///
        public let maximumExecutionFrequency: MaximumExecutionFrequency?
        /// The type of notification that triggers Config to run an
        /// 			evaluation for a rule. You can specify the following notification
        /// 			types:
        ///
        ///
        /// 					             ConfigurationItemChangeNotification - Triggers
        /// 					an evaluation when Config delivers a configuration item
        /// 					as a result of a resource change.
        ///
        /// 				            OversizedConfigurationItemChangeNotification
        /// 					- Triggers an evaluation when Config delivers an
        /// 					oversized configuration item. Config may generate this
        /// 					notification type when a resource changes and the
        /// 					notification exceeds the maximum size allowed by Amazon
        /// 					SNS.
        ///
        /// 				            ScheduledNotification - Triggers a
        /// 					periodic evaluation at the frequency specified for
        /// 						MaximumExecutionFrequency.
        ///
        /// 				            ConfigurationSnapshotDeliveryCompleted -
        /// 					Triggers a periodic evaluation when Config delivers a
        /// 					configuration snapshot.
        ///
        /// 		       If you want your custom rule to be triggered by configuration
        /// 			changes, specify two SourceDetail objects, one for
        /// 				ConfigurationItemChangeNotification and one for
        /// 				OversizedConfigurationItemChangeNotification.
        public let messageType: MessageType?

        public init(eventSource: EventSource? = nil, maximumExecutionFrequency: MaximumExecutionFrequency? = nil, messageType: MessageType? = nil) {
            self.eventSource = eventSource
            self.maximumExecutionFrequency = maximumExecutionFrequency
            self.messageType = messageType
        }

        private enum CodingKeys: String, CodingKey {
            case eventSource = "EventSource"
            case maximumExecutionFrequency = "MaximumExecutionFrequency"
            case messageType = "MessageType"
        }
    }

    public struct SsmControls: AWSEncodableShape & AWSDecodableShape {
        /// The maximum percentage of remediation actions allowed to run in parallel on the non-compliant resources for that specific rule. You can specify a percentage, such as 10%. The default value is 10.
        public let concurrentExecutionRatePercentage: Int?
        /// The percentage of errors that are allowed before SSM stops running automations on non-compliant resources for that specific rule.
        /// 			You can specify a percentage of errors, for example 10%. If you do not specifiy a percentage, the default is 50%.
        /// 			For example, if you set the ErrorPercentage to 40% for 10 non-compliant resources, then SSM stops running the automations when the fifth error is received.
        public let errorPercentage: Int?

        public init(concurrentExecutionRatePercentage: Int? = nil, errorPercentage: Int? = nil) {
            self.concurrentExecutionRatePercentage = concurrentExecutionRatePercentage
            self.errorPercentage = errorPercentage
        }

        public func validate(name: String) throws {
            try self.validate(self.concurrentExecutionRatePercentage, name: "concurrentExecutionRatePercentage", parent: name, max: 100)
            try self.validate(self.concurrentExecutionRatePercentage, name: "concurrentExecutionRatePercentage", parent: name, min: 1)
            try self.validate(self.errorPercentage, name: "errorPercentage", parent: name, max: 100)
            try self.validate(self.errorPercentage, name: "errorPercentage", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case concurrentExecutionRatePercentage = "ConcurrentExecutionRatePercentage"
            case errorPercentage = "ErrorPercentage"
        }
    }

    public struct StartConfigRulesEvaluationRequest: AWSEncodableShape {
        /// The list of names of Config rules that you want to run
        /// 			evaluations for.
        public let configRuleNames: [String]?

        public init(configRuleNames: [String]? = nil) {
            self.configRuleNames = configRuleNames
        }

        public func validate(name: String) throws {
            try self.configRuleNames?.forEach {
                try validate($0, name: "configRuleNames[]", parent: name, max: 128)
                try validate($0, name: "configRuleNames[]", parent: name, min: 1)
                try validate($0, name: "configRuleNames[]", parent: name, pattern: "\\S")
            }
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, max: 25)
            try self.validate(self.configRuleNames, name: "configRuleNames", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleNames = "ConfigRuleNames"
        }
    }

    public struct StartConfigRulesEvaluationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct StartConfigurationRecorderRequest: AWSEncodableShape {
        /// The name of the recorder object that records each configuration
        /// 			change made to the resources.
        public let configurationRecorderName: String

        public init(configurationRecorderName: String) {
            self.configurationRecorderName = configurationRecorderName
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, max: 256)
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorderName = "ConfigurationRecorderName"
        }
    }

    public struct StartRemediationExecutionRequest: AWSEncodableShape {
        /// The list of names of Config rules that you want to run remediation execution for.
        public let configRuleName: String
        /// A list of resource keys to be processed with the current request. Each element in the list consists of the resource type and resource ID.
        public let resourceKeys: [ResourceKey]

        public init(configRuleName: String, resourceKeys: [ResourceKey]) {
            self.configRuleName = configRuleName
            self.resourceKeys = resourceKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, max: 128)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, min: 1)
            try self.validate(self.configRuleName, name: "configRuleName", parent: name, pattern: "\\S")
            try self.resourceKeys.forEach {
                try $0.validate(name: "\(name).resourceKeys[]")
            }
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, max: 100)
            try self.validate(self.resourceKeys, name: "resourceKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configRuleName = "ConfigRuleName"
            case resourceKeys = "ResourceKeys"
        }
    }

    public struct StartRemediationExecutionResponse: AWSDecodableShape {
        /// For resources that have failed to start execution, the API returns a resource key object.
        public let failedItems: [ResourceKey]?
        /// Returns a failure message. For example, the resource is already compliant.
        public let failureMessage: String?

        public init(failedItems: [ResourceKey]? = nil, failureMessage: String? = nil) {
            self.failedItems = failedItems
            self.failureMessage = failureMessage
        }

        private enum CodingKeys: String, CodingKey {
            case failedItems = "FailedItems"
            case failureMessage = "FailureMessage"
        }
    }

    public struct StartResourceEvaluationRequest: AWSEncodableShape {
        /// A client token is a unique, case-sensitive string of up to 64 ASCII characters.
        /// 			To make an idempotent API request using one of these actions, specify a client token in the request.
        /// 		        Avoid reusing the same client token for other API requests. If you retry
        /// 				a request that completed successfully using the same client token and the same
        /// 				parameters, the retry succeeds without performing any further actions. If you retry
        /// 				a successful request using the same client token, but one or more of the parameters
        /// 				are different, other than the Region or Availability Zone, the retry fails with an
        /// 				IdempotentParameterMismatch error.
        public let clientToken: String?
        /// Returns an EvaluationContext object.
        public let evaluationContext: EvaluationContext?
        /// The mode of an evaluation. The valid value for this API is Proactive.
        public let evaluationMode: EvaluationMode
        /// The timeout for an evaluation. The default is 900 seconds. You cannot specify a number greater than 3600. If you specify 0, Config uses the default.
        public let evaluationTimeout: Int?
        /// Returns a ResourceDetails object.
        public let resourceDetails: ResourceDetails

        public init(clientToken: String? = nil, evaluationContext: EvaluationContext? = nil, evaluationMode: EvaluationMode, evaluationTimeout: Int? = nil, resourceDetails: ResourceDetails) {
            self.clientToken = clientToken
            self.evaluationContext = evaluationContext
            self.evaluationMode = evaluationMode
            self.evaluationTimeout = evaluationTimeout
            self.resourceDetails = resourceDetails
        }

        public func validate(name: String) throws {
            try self.validate(self.clientToken, name: "clientToken", parent: name, max: 256)
            try self.validate(self.clientToken, name: "clientToken", parent: name, min: 64)
            try self.evaluationContext?.validate(name: "\(name).evaluationContext")
            try self.validate(self.evaluationTimeout, name: "evaluationTimeout", parent: name, max: 3600)
            try self.validate(self.evaluationTimeout, name: "evaluationTimeout", parent: name, min: 0)
            try self.resourceDetails.validate(name: "\(name).resourceDetails")
        }

        private enum CodingKeys: String, CodingKey {
            case clientToken = "ClientToken"
            case evaluationContext = "EvaluationContext"
            case evaluationMode = "EvaluationMode"
            case evaluationTimeout = "EvaluationTimeout"
            case resourceDetails = "ResourceDetails"
        }
    }

    public struct StartResourceEvaluationResponse: AWSDecodableShape {
        /// A
        /// 			unique ResourceEvaluationId that is associated with a single execution.
        public let resourceEvaluationId: String?

        public init(resourceEvaluationId: String? = nil) {
            self.resourceEvaluationId = resourceEvaluationId
        }

        private enum CodingKeys: String, CodingKey {
            case resourceEvaluationId = "ResourceEvaluationId"
        }
    }

    public struct StaticValue: AWSEncodableShape & AWSDecodableShape {
        /// A list of values. For example, the ARN of the assumed role.
        public let values: [String]

        public init(values: [String]) {
            self.values = values
        }

        public func validate(name: String) throws {
            try self.values.forEach {
                try validate($0, name: "values[]", parent: name, max: 256)
                try validate($0, name: "values[]", parent: name, min: 1)
            }
            try self.validate(self.values, name: "values", parent: name, max: 25)
        }

        private enum CodingKeys: String, CodingKey {
            case values = "Values"
        }
    }

    public struct StatusDetailFilters: AWSEncodableShape {
        /// The 12-digit account ID of the member account within an organization.
        public let accountId: String?
        /// Indicates deployment status for Config rule in the member account.
        /// 			When management account calls PutOrganizationConfigRule action for the first time, Config rule status is created in the member account.
        /// 			When management account calls PutOrganizationConfigRule action for the second time, Config rule status is updated in the member account.
        /// 			Config rule status is deleted when the management account deletes OrganizationConfigRule and disables service access for config-multiaccountsetup.amazonaws.com.
        ///
        /// 		       Config sets the state of the rule to:
        /// 		          CREATE_SUCCESSFUL when Config rule has been created in the member account.    CREATE_IN_PROGRESS when Config rule is being created in the member account.    CREATE_FAILED when Config rule creation has failed in the member account.    DELETE_FAILED when Config rule deletion has failed in the member account.    DELETE_IN_PROGRESS when Config rule is being deleted in the member account.    DELETE_SUCCESSFUL when Config rule has been deleted in the member account.    UPDATE_SUCCESSFUL when Config rule has been updated in the member account.    UPDATE_IN_PROGRESS when Config rule is being updated in the member account.    UPDATE_FAILED when Config rule deletion has failed in the member account.
        public let memberAccountRuleStatus: MemberAccountRuleStatus?

        public init(accountId: String? = nil, memberAccountRuleStatus: MemberAccountRuleStatus? = nil) {
            self.accountId = accountId
            self.memberAccountRuleStatus = memberAccountRuleStatus
        }

        public func validate(name: String) throws {
            try self.validate(self.accountId, name: "accountId", parent: name, pattern: "^\\d{12}$")
        }

        private enum CodingKeys: String, CodingKey {
            case accountId = "AccountId"
            case memberAccountRuleStatus = "MemberAccountRuleStatus"
        }
    }

    public struct StopConfigurationRecorderRequest: AWSEncodableShape {
        /// The name of the recorder object that records each configuration change made to the resources.
        public let configurationRecorderName: String

        public init(configurationRecorderName: String) {
            self.configurationRecorderName = configurationRecorderName
        }

        public func validate(name: String) throws {
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, max: 256)
            try self.validate(self.configurationRecorderName, name: "configurationRecorderName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationRecorderName = "ConfigurationRecorderName"
        }
    }

    public struct StoredQuery: AWSEncodableShape & AWSDecodableShape {
        /// A unique description for the query.
        public let description: String?
        /// The expression of the query. For example, SELECT
        /// 			resourceId,
        /// 			resourceType,
        /// 			supplementaryConfiguration.BucketVersioningConfiguration.status
        /// 			WHERE
        /// 			resourceType = 'AWS::S3::Bucket'
        /// 			AND supplementaryConfiguration.BucketVersioningConfiguration.status = 'Off'.
        public let expression: String?
        /// Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.
        public let queryArn: String?
        /// The ID of the query.
        public let queryId: String?
        /// The name of the query.
        public let queryName: String

        public init(description: String? = nil, expression: String? = nil, queryArn: String? = nil, queryId: String? = nil, queryName: String) {
            self.description = description
            self.expression = expression
            self.queryArn = queryArn
            self.queryId = queryId
            self.queryName = queryName
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.description, name: "description", parent: name, pattern: "^[\\s\\S]*$")
            try self.validate(self.expression, name: "expression", parent: name, max: 4096)
            try self.validate(self.expression, name: "expression", parent: name, min: 1)
            try self.validate(self.expression, name: "expression", parent: name, pattern: "^[\\s\\S]*$")
            try self.validate(self.queryArn, name: "queryArn", parent: name, max: 500)
            try self.validate(self.queryArn, name: "queryArn", parent: name, min: 1)
            try self.validate(self.queryArn, name: "queryArn", parent: name, pattern: "^arn:aws[a-z\\-]*:config:[a-z\\-\\d]+:\\d+:stored-query/[a-zA-Z0-9-_]+/query-[a-zA-Z\\d-_/]+$")
            try self.validate(self.queryId, name: "queryId", parent: name, max: 36)
            try self.validate(self.queryId, name: "queryId", parent: name, min: 1)
            try self.validate(self.queryId, name: "queryId", parent: name, pattern: "^\\S+$")
            try self.validate(self.queryName, name: "queryName", parent: name, max: 64)
            try self.validate(self.queryName, name: "queryName", parent: name, min: 1)
            try self.validate(self.queryName, name: "queryName", parent: name, pattern: "^[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case expression = "Expression"
            case queryArn = "QueryArn"
            case queryId = "QueryId"
            case queryName = "QueryName"
        }
    }

    public struct StoredQueryMetadata: AWSDecodableShape {
        /// A unique description for the query.
        public let description: String?
        /// Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.
        public let queryArn: String
        /// The ID of the query.
        public let queryId: String
        /// The name of the query.
        public let queryName: String

        public init(description: String? = nil, queryArn: String, queryId: String, queryName: String) {
            self.description = description
            self.queryArn = queryArn
            self.queryId = queryId
            self.queryName = queryName
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case queryArn = "QueryArn"
            case queryId = "QueryId"
            case queryName = "QueryName"
        }
    }

    public struct Tag: AWSEncodableShape & AWSDecodableShape {
        /// One part of a key-value pair that make up a tag. A key is a general label that acts like a category for more specific tag values.
        public let key: String?
        /// The optional part of a key-value pair that make up a tag. A value acts as a descriptor within a tag category (key).
        public let value: String?

        public init(key: String? = nil, value: String? = nil) {
            self.key = key
            self.value = value
        }

        public func validate(name: String) throws {
            try self.validate(self.key, name: "key", parent: name, max: 128)
            try self.validate(self.key, name: "key", parent: name, min: 1)
            try self.validate(self.value, name: "value", parent: name, max: 256)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case value = "Value"
        }
    }

    public struct TagResourceRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are ConfigRule, ConfigurationAggregator and AggregatorAuthorization.
        public let resourceArn: String
        /// An array of tag object.
        public let tags: [Tag]

        public init(resourceArn: String, tags: [Tag]) {
            self.resourceArn = resourceArn
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 1000)
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, min: 1)
            try self.tags.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try self.validate(self.tags, name: "tags", parent: name, max: 50)
            try self.validate(self.tags, name: "tags", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceArn = "ResourceArn"
            case tags = "Tags"
        }
    }

    public struct TemplateSSMDocumentDetails: AWSEncodableShape & AWSDecodableShape {
        /// The name or Amazon Resource Name (ARN) of the SSM document to use to create a conformance pack.
        /// 			If you use the document name, Config checks only your account and Amazon Web Services Region for the SSM document. If you want to use an SSM document from another Region or account, you must provide the ARN.
        public let documentName: String
        /// The version of the SSM document to use to create a conformance pack. By default, Config uses the latest version.
        /// 		        This field is optional.
        public let documentVersion: String?

        public init(documentName: String, documentVersion: String? = nil) {
            self.documentName = documentName
            self.documentVersion = documentVersion
        }

        public func validate(name: String) throws {
            try self.validate(self.documentName, name: "documentName", parent: name, pattern: "^[a-zA-Z0-9_\\-.:/]{3,200}$")
            try self.validate(self.documentVersion, name: "documentVersion", parent: name, pattern: "^([$]LATEST|[$]DEFAULT|^[1-9][0-9]*$)$")
        }

        private enum CodingKeys: String, CodingKey {
            case documentName = "DocumentName"
            case documentVersion = "DocumentVersion"
        }
    }

    public struct TimeWindow: AWSEncodableShape {
        /// The end time of an execution. The end time must be after the start date.
        public let endTime: Date?
        /// The start time of an execution.
        public let startTime: Date?

        public init(endTime: Date? = nil, startTime: Date? = nil) {
            self.endTime = endTime
            self.startTime = startTime
        }

        private enum CodingKeys: String, CodingKey {
            case endTime = "EndTime"
            case startTime = "StartTime"
        }
    }

    public struct UntagResourceRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are ConfigRule, ConfigurationAggregator and AggregatorAuthorization.
        public let resourceArn: String
        /// The keys of the tags to be removed.
        public let tagKeys: [String]

        public init(resourceArn: String, tagKeys: [String]) {
            self.resourceArn = resourceArn
            self.tagKeys = tagKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, max: 1000)
            try self.validate(self.resourceArn, name: "resourceArn", parent: name, min: 1)
            try self.tagKeys.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 128)
                try validate($0, name: "tagKeys[]", parent: name, min: 1)
            }
            try self.validate(self.tagKeys, name: "tagKeys", parent: name, max: 50)
            try self.validate(self.tagKeys, name: "tagKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceArn = "ResourceArn"
            case tagKeys = "TagKeys"
        }
    }
}

// MARK: - Errors

/// Error enum for ConfigService
public struct ConfigServiceErrorType: AWSErrorType {
    enum Code: String {
        case conformancePackTemplateValidationException = "ConformancePackTemplateValidationException"
        case idempotentParameterMismatch = "IdempotentParameterMismatch"
        case insufficientDeliveryPolicyException = "InsufficientDeliveryPolicyException"
        case insufficientPermissionsException = "InsufficientPermissionsException"
        case invalidConfigurationRecorderNameException = "InvalidConfigurationRecorderNameException"
        case invalidDeliveryChannelNameException = "InvalidDeliveryChannelNameException"
        case invalidExpressionException = "InvalidExpressionException"
        case invalidLimitException = "InvalidLimitException"
        case invalidNextTokenException = "InvalidNextTokenException"
        case invalidParameterValueException = "InvalidParameterValueException"
        case invalidRecordingGroupException = "InvalidRecordingGroupException"
        case invalidResultTokenException = "InvalidResultTokenException"
        case invalidRoleException = "InvalidRoleException"
        case invalidS3KeyPrefixException = "InvalidS3KeyPrefixException"
        case invalidS3KmsKeyArnException = "InvalidS3KmsKeyArnException"
        case invalidSNSTopicARNException = "InvalidSNSTopicARNException"
        case invalidTimeRangeException = "InvalidTimeRangeException"
        case lastDeliveryChannelDeleteFailedException = "LastDeliveryChannelDeleteFailedException"
        case limitExceededException = "LimitExceededException"
        case maxActiveResourcesExceededException = "MaxActiveResourcesExceededException"
        case maxNumberOfConfigRulesExceededException = "MaxNumberOfConfigRulesExceededException"
        case maxNumberOfConfigurationRecordersExceededException = "MaxNumberOfConfigurationRecordersExceededException"
        case maxNumberOfConformancePacksExceededException = "MaxNumberOfConformancePacksExceededException"
        case maxNumberOfDeliveryChannelsExceededException = "MaxNumberOfDeliveryChannelsExceededException"
        case maxNumberOfOrganizationConfigRulesExceededException = "MaxNumberOfOrganizationConfigRulesExceededException"
        case maxNumberOfOrganizationConformancePacksExceededException = "MaxNumberOfOrganizationConformancePacksExceededException"
        case maxNumberOfRetentionConfigurationsExceededException = "MaxNumberOfRetentionConfigurationsExceededException"
        case noAvailableConfigurationRecorderException = "NoAvailableConfigurationRecorderException"
        case noAvailableDeliveryChannelException = "NoAvailableDeliveryChannelException"
        case noAvailableOrganizationException = "NoAvailableOrganizationException"
        case noRunningConfigurationRecorderException = "NoRunningConfigurationRecorderException"
        case noSuchBucketException = "NoSuchBucketException"
        case noSuchConfigRuleException = "NoSuchConfigRuleException"
        case noSuchConfigRuleInConformancePackException = "NoSuchConfigRuleInConformancePackException"
        case noSuchConfigurationAggregatorException = "NoSuchConfigurationAggregatorException"
        case noSuchConfigurationRecorderException = "NoSuchConfigurationRecorderException"
        case noSuchConformancePackException = "NoSuchConformancePackException"
        case noSuchDeliveryChannelException = "NoSuchDeliveryChannelException"
        case noSuchOrganizationConfigRuleException = "NoSuchOrganizationConfigRuleException"
        case noSuchOrganizationConformancePackException = "NoSuchOrganizationConformancePackException"
        case noSuchRemediationConfigurationException = "NoSuchRemediationConfigurationException"
        case noSuchRemediationExceptionException = "NoSuchRemediationExceptionException"
        case noSuchRetentionConfigurationException = "NoSuchRetentionConfigurationException"
        case organizationAccessDeniedException = "OrganizationAccessDeniedException"
        case organizationAllFeaturesNotEnabledException = "OrganizationAllFeaturesNotEnabledException"
        case organizationConformancePackTemplateValidationException = "OrganizationConformancePackTemplateValidationException"
        case oversizedConfigurationItemException = "OversizedConfigurationItemException"
        case remediationInProgressException = "RemediationInProgressException"
        case resourceConcurrentModificationException = "ResourceConcurrentModificationException"
        case resourceInUseException = "ResourceInUseException"
        case resourceNotDiscoveredException = "ResourceNotDiscoveredException"
        case resourceNotFoundException = "ResourceNotFoundException"
        case tooManyTagsException = "TooManyTagsException"
        case validationException = "ValidationException"
    }

    private let error: Code
    public let context: AWSErrorContext?

    /// initialize ConfigService
    public init?(errorCode: String, context: AWSErrorContext) {
        guard let error = Code(rawValue: errorCode) else { return nil }
        self.error = error
        self.context = context
    }

    internal init(_ error: Code) {
        self.error = error
        self.context = nil
    }

    /// return error code string
    public var errorCode: String { self.error.rawValue }

    /// You have specified a template that is invalid or supported.
    public static var conformancePackTemplateValidationException: Self { .init(.conformancePackTemplateValidationException) }
    /// Using the same client token with one or more different parameters. Specify a new client token with the parameter changes and try again.
    public static var idempotentParameterMismatch: Self { .init(.idempotentParameterMismatch) }
    /// Your Amazon S3 bucket policy does not permit Config to
    /// 			write to it.
    public static var insufficientDeliveryPolicyException: Self { .init(.insufficientDeliveryPolicyException) }
    /// Indicates one of the following errors:
    /// 		         For PutConfigRule, the rule cannot be created because the IAM role assigned to Config lacks permissions to perform the config:Put* action.   For PutConfigRule, the Lambda function cannot be invoked. Check the function ARN, and check the function&#39;s permissions.   For PutOrganizationConfigRule, organization Config rule cannot be created because you do not have permissions to call IAM GetRole action or create a service-linked role.   For PutConformancePack and PutOrganizationConformancePack, a conformance pack cannot be created because you do not have the following permissions:
    /// 				             You do not have permission to call IAM GetRole action or create a service-linked role.   You do not have permission to read Amazon S3 bucket or call SSM:GetDocument.
    ///
    public static var insufficientPermissionsException: Self { .init(.insufficientPermissionsException) }
    /// You have provided a configuration recorder name that is not
    /// 			valid.
    public static var invalidConfigurationRecorderNameException: Self { .init(.invalidConfigurationRecorderNameException) }
    /// The specified delivery channel name is invalid.
    public static var invalidDeliveryChannelNameException: Self { .init(.invalidDeliveryChannelNameException) }
    /// The syntax of the query is incorrect.
    public static var invalidExpressionException: Self { .init(.invalidExpressionException) }
    /// The specified limit is outside the allowable range.
    public static var invalidLimitException: Self { .init(.invalidLimitException) }
    /// The specified next token is invalid. Specify the
    /// 				nextToken string that was returned in the previous
    /// 			response to get the next page of results.
    public static var invalidNextTokenException: Self { .init(.invalidNextTokenException) }
    /// One or more of the specified parameters are invalid. Verify
    /// 			that your parameters are valid and try again.
    public static var invalidParameterValueException: Self { .init(.invalidParameterValueException) }
    /// Config throws an exception if the recording group does not contain a valid list of resource types. Invalid values might also be incorrectly formatted.
    public static var invalidRecordingGroupException: Self { .init(.invalidRecordingGroupException) }
    /// The specified ResultToken is invalid.
    public static var invalidResultTokenException: Self { .init(.invalidResultTokenException) }
    /// You have provided a null or empty role ARN.
    public static var invalidRoleException: Self { .init(.invalidRoleException) }
    /// The specified Amazon S3 key prefix is invalid.
    public static var invalidS3KeyPrefixException: Self { .init(.invalidS3KeyPrefixException) }
    /// The specified Amazon KMS Key ARN is invalid.
    public static var invalidS3KmsKeyArnException: Self { .init(.invalidS3KmsKeyArnException) }
    /// The specified Amazon SNS topic does not exist.
    public static var invalidSNSTopicARNException: Self { .init(.invalidSNSTopicARNException) }
    /// The specified time range is invalid. The earlier time is not
    /// 			chronologically before the later time.
    public static var invalidTimeRangeException: Self { .init(.invalidTimeRangeException) }
    /// You cannot delete the delivery channel you specified because
    /// 			the configuration recorder is running.
    public static var lastDeliveryChannelDeleteFailedException: Self { .init(.lastDeliveryChannelDeleteFailedException) }
    /// For StartConfigRulesEvaluation API, this exception
    /// 			is thrown if an evaluation is in progress or if you call the StartConfigRulesEvaluation API more than once per
    /// 			minute.
    /// 		       For PutConfigurationAggregator API, this exception
    /// 			is thrown if the number of accounts and aggregators exceeds the
    /// 			limit.
    public static var limitExceededException: Self { .init(.limitExceededException) }
    /// You have reached the limit of active custom resource types in your account. There is a limit of 100,000.
    /// 			Delete unused resources using DeleteResourceConfig .
    public static var maxActiveResourcesExceededException: Self { .init(.maxActiveResourcesExceededException) }
    /// Failed to add the Config rule because the account already
    /// 			contains the maximum number of 150 rules. Consider deleting any
    /// 			deactivated rules before you add new rules.
    public static var maxNumberOfConfigRulesExceededException: Self { .init(.maxNumberOfConfigRulesExceededException) }
    /// You have reached the limit of the number of recorders you can
    /// 			create.
    public static var maxNumberOfConfigurationRecordersExceededException: Self { .init(.maxNumberOfConfigurationRecordersExceededException) }
    /// You have reached the limit of the number of conformance packs you can create in an account. For more information, see  Service Limits in the Config Developer Guide.
    public static var maxNumberOfConformancePacksExceededException: Self { .init(.maxNumberOfConformancePacksExceededException) }
    /// You have reached the limit of the number of delivery channels
    /// 			you can create.
    public static var maxNumberOfDeliveryChannelsExceededException: Self { .init(.maxNumberOfDeliveryChannelsExceededException) }
    /// You have reached the limit of the number of organization Config rules you can create. For more information, see see  Service Limits in the Config Developer Guide.
    public static var maxNumberOfOrganizationConfigRulesExceededException: Self { .init(.maxNumberOfOrganizationConfigRulesExceededException) }
    /// You have reached the limit of the number of organization conformance packs you can create in an account. For more information, see  Service Limits in the Config Developer Guide.
    public static var maxNumberOfOrganizationConformancePacksExceededException: Self { .init(.maxNumberOfOrganizationConformancePacksExceededException) }
    /// Failed to add the retention configuration because a retention configuration with that name already exists.
    public static var maxNumberOfRetentionConfigurationsExceededException: Self { .init(.maxNumberOfRetentionConfigurationsExceededException) }
    /// There are no configuration recorders available to provide the
    /// 			role needed to describe your resources. Create a configuration
    /// 			recorder.
    public static var noAvailableConfigurationRecorderException: Self { .init(.noAvailableConfigurationRecorderException) }
    /// There is no delivery channel available to record
    /// 			configurations.
    public static var noAvailableDeliveryChannelException: Self { .init(.noAvailableDeliveryChannelException) }
    /// Organization is no longer available.
    public static var noAvailableOrganizationException: Self { .init(.noAvailableOrganizationException) }
    /// There is no configuration recorder running.
    public static var noRunningConfigurationRecorderException: Self { .init(.noRunningConfigurationRecorderException) }
    /// The specified Amazon S3 bucket does not exist.
    public static var noSuchBucketException: Self { .init(.noSuchBucketException) }
    /// The Config rule in the request is invalid. Verify that the rule is an Config Custom Policy rule, that the rule name is correct, and that valid Amazon Resouce Names (ARNs) are used before trying again.
    public static var noSuchConfigRuleException: Self { .init(.noSuchConfigRuleException) }
    /// Config rule that you passed in the filter does not exist.
    public static var noSuchConfigRuleInConformancePackException: Self { .init(.noSuchConfigRuleInConformancePackException) }
    /// You have specified a configuration aggregator that does not exist.
    public static var noSuchConfigurationAggregatorException: Self { .init(.noSuchConfigurationAggregatorException) }
    /// You have specified a configuration recorder that does not
    /// 			exist.
    public static var noSuchConfigurationRecorderException: Self { .init(.noSuchConfigurationRecorderException) }
    /// You specified one or more conformance packs that do not exist.
    public static var noSuchConformancePackException: Self { .init(.noSuchConformancePackException) }
    /// You have specified a delivery channel that does not
    /// 			exist.
    public static var noSuchDeliveryChannelException: Self { .init(.noSuchDeliveryChannelException) }
    /// The Config rule in the request is invalid. Verify that the rule is an organization Config Custom Policy rule, that the rule name is correct, and that valid Amazon Resouce Names (ARNs) are used before trying again.
    public static var noSuchOrganizationConfigRuleException: Self { .init(.noSuchOrganizationConfigRuleException) }
    /// Config organization conformance pack that you passed in the filter does not exist.
    /// 		       For DeleteOrganizationConformancePack, you tried to delete an organization conformance pack that does not exist.
    public static var noSuchOrganizationConformancePackException: Self { .init(.noSuchOrganizationConformancePackException) }
    /// You specified an Config rule without a remediation configuration.
    public static var noSuchRemediationConfigurationException: Self { .init(.noSuchRemediationConfigurationException) }
    /// You tried to delete a remediation exception that does not exist.
    public static var noSuchRemediationExceptionException: Self { .init(.noSuchRemediationExceptionException) }
    /// You have specified a retention configuration that does not exist.
    public static var noSuchRetentionConfigurationException: Self { .init(.noSuchRetentionConfigurationException) }
    /// For PutConfigurationAggregator API, you can see this exception for the following reasons:
    /// 		         No permission to call EnableAWSServiceAccess API   The configuration aggregator cannot be updated because your Amazon Web Services Organization management account or the delegated administrator role changed.
    /// 				Delete this aggregator and create a new one with the current Amazon Web Services Organization.   The configuration aggregator is associated with a previous Amazon Web Services Organization and Config cannot aggregate data with current Amazon Web Services Organization.
    /// 				Delete this aggregator and create a new one with the current Amazon Web Services Organization.   You are not a registered delegated administrator for Config with permissions to call ListDelegatedAdministrators API.
    /// 			Ensure that the management account registers delagated administrator for Config service principle name before the delegated administrator creates an aggregator.
    /// 		       For all OrganizationConfigRule and OrganizationConformancePack APIs, Config throws an exception if APIs are called from member accounts. All APIs must be called from organization management account.
    public static var organizationAccessDeniedException: Self { .init(.organizationAccessDeniedException) }
    /// Config resource cannot be created because your organization does not have all features enabled.
    public static var organizationAllFeaturesNotEnabledException: Self { .init(.organizationAllFeaturesNotEnabledException) }
    /// You have specified a template that is invalid or supported.
    public static var organizationConformancePackTemplateValidationException: Self { .init(.organizationConformancePackTemplateValidationException) }
    /// The configuration item size is outside the allowable range.
    public static var oversizedConfigurationItemException: Self { .init(.oversizedConfigurationItemException) }
    /// Remediation action is in progress. You can either cancel execution in Amazon Web Services Systems Manager or wait and try again later.
    public static var remediationInProgressException: Self { .init(.remediationInProgressException) }
    /// Two users are trying to modify the same query at the same time. Wait for a moment and try again.
    public static var resourceConcurrentModificationException: Self { .init(.resourceConcurrentModificationException) }
    /// You see this exception in the following cases:
    /// 		         For DeleteConfigRule, Config is deleting this rule. Try your request again later.   For DeleteConfigRule, the rule is deleting your evaluation results. Try your request again later.   For DeleteConfigRule, a remediation action is associated with the rule and Config cannot delete this rule. Delete the remediation action associated with the rule before deleting the rule and try your request again later.   For PutConfigOrganizationRule, organization Config rule deletion is in progress. Try your request again later.   For DeleteOrganizationConfigRule, organization Config rule creation is in progress. Try your request again later.   For PutConformancePack and PutOrganizationConformancePack, a conformance pack creation, update, and deletion is in progress. Try your request again later.   For DeleteConformancePack, a conformance pack creation, update, and deletion is in progress. Try your request again later.
    public static var resourceInUseException: Self { .init(.resourceInUseException) }
    /// You have specified a resource that is either unknown or has not
    /// 			been discovered.
    public static var resourceNotDiscoveredException: Self { .init(.resourceNotDiscoveredException) }
    /// You have specified a resource that does not exist.
    public static var resourceNotFoundException: Self { .init(.resourceNotFoundException) }
    /// You have reached the limit of the number of tags you can use.
    /// 			For more information, see  Service Limits in the Config Developer Guide.
    public static var tooManyTagsException: Self { .init(.tooManyTagsException) }
    /// The requested action is invalid.
    /// 		       For PutStoredQuery, you will see this exception if there are missing required fields or if the input value fails the validation, or if you are trying to create more than 300 queries.
    /// 		       For GetStoredQuery, ListStoredQuery, and DeleteStoredQuery you will see this exception if there are missing required fields or if the input value fails the validation.
    public static var validationException: Self { .init(.validationException) }
}

extension ConfigServiceErrorType: Equatable {
    public static func == (lhs: ConfigServiceErrorType, rhs: ConfigServiceErrorType) -> Bool {
        lhs.error == rhs.error
    }
}

extension ConfigServiceErrorType: CustomStringConvertible {
    public var description: String {
        return "\(self.error.rawValue): \(self.message ?? "")"
    }
}
